Bumping version to 1.4.0 and generate CHANGELOG (#6727 )

Co-authored-by: Github Build Bot <buildbot@fishtownanalytics.com>
CT 1886 include adapter_response in NodeFinished log message (#6709 ) (#6714 )
2025-12-19 20:21:27 +00:00 · 2023-01-25 10:17:36 -05:00 · 2023-01-24 15:38:51 -05:00 · 2023-01-20 12:26:32 -08:00 · 2023-01-19 12:13:06 -05:00 · 2023-01-19 10:24:49 -05:00
250 changed files with 23166 additions and 5797 deletions
--- a/.bumpversion.cfg
+++ b/.bumpversion.cfg
@@ -1,5 +1,5 @@
 [bumpversion]
-current_version = 1.5.0a1
+current_version = 1.4.0
 parse = (?P<major>\d+)
 	\.(?P<minor>\d+)
 	\.(?P<patch>\d+)
--- a/.changes/0.0.0.md
+++ b/.changes/0.0.0.md
@@ -3,7 +3,6 @@
 For information on prior major and minor releases, see their changelogs:


-* [1.4](https://github.com/dbt-labs/dbt-core/blob/1.4.latest/CHANGELOG.md)
 * [1.3](https://github.com/dbt-labs/dbt-core/blob/1.3.latest/CHANGELOG.md)
 * [1.2](https://github.com/dbt-labs/dbt-core/blob/1.2.latest/CHANGELOG.md)
 * [1.1](https://github.com/dbt-labs/dbt-core/blob/1.1.latest/CHANGELOG.md)
--- a/.changes/1.4.0.md
+++ b/.changes/1.4.0.md
@@ -0,0 +1,126 @@
+## dbt-core 1.4.0 - January 25, 2023
+
+### Breaking Changes
+
+- Cleaned up exceptions to directly raise in code.  Also updated the existing exception to meet PEP guidelines.Removed use of all exception functions in the code base and marked them all as deprecated to be removed next minor release. ([#6339](https://github.com/dbt-labs/dbt-core/issues/6339), [#6393](https://github.com/dbt-labs/dbt-core/issues/6393), [#6460](https://github.com/dbt-labs/dbt-core/issues/6460))
+
+### Features
+
+- Added favor-state flag to optionally favor state nodes even if unselected node exists ([#5016](https://github.com/dbt-labs/dbt-core/issues/5016))
+- Update structured logging. Convert to using protobuf messages. Ensure events are enriched with node_info. ([#5610](https://github.com/dbt-labs/dbt-core/issues/5610))
+- incremental predicates ([#5680](https://github.com/dbt-labs/dbt-core/issues/5680))
+- Friendlier error messages when packages.yml is malformed ([#5486](https://github.com/dbt-labs/dbt-core/issues/5486))
+- Allow partitions in external tables to be supplied as a list ([#5929](https://github.com/dbt-labs/dbt-core/issues/5929))
+- extend -f flag shorthand for seed command ([#5990](https://github.com/dbt-labs/dbt-core/issues/5990))
+- This pulls the profile name from args when constructing a RuntimeConfig in lib.py, enabling the dbt-server to override the value that's in the dbt_project.yml ([#6201](https://github.com/dbt-labs/dbt-core/issues/6201))
+- Adding tarball install method for packages. Allowing package tarball to be specified via url in the packages.yaml. ([#4205](https://github.com/dbt-labs/dbt-core/issues/4205))
+- Added an md5 function to the base context ([#6246](https://github.com/dbt-labs/dbt-core/issues/6246))
+- Exposures support metrics in lineage ([#6057](https://github.com/dbt-labs/dbt-core/issues/6057))
+- Add support for Python 3.11 ([#6147](https://github.com/dbt-labs/dbt-core/issues/6147))
+- Making timestamp optional for metrics ([#6398](https://github.com/dbt-labs/dbt-core/issues/6398))
+- The meta configuration field is now included in the node_info property of structured logs. ([#6216](https://github.com/dbt-labs/dbt-core/issues/6216))
+- Adds buildable selection mode ([#6365](https://github.com/dbt-labs/dbt-core/issues/6365))
+- --warn-error-options: Treat warnings as errors for specific events, based on user configuration ([#6165](https://github.com/dbt-labs/dbt-core/issues/6165))
+
+### Fixes
+
+- Account for disabled flags on models in schema files more completely ([#3992](https://github.com/dbt-labs/dbt-core/issues/3992))
+- Add validation of enabled config for metrics, exposures and sources ([#6030](https://github.com/dbt-labs/dbt-core/issues/6030))
+- check length of args of python model function before accessing it ([#6041](https://github.com/dbt-labs/dbt-core/issues/6041))
+- Add functors to ensure event types with str-type attributes are initialized to spec, even when provided non-str type params. ([#5436](https://github.com/dbt-labs/dbt-core/issues/5436))
+- Allow hooks to fail without halting execution flow ([#5625](https://github.com/dbt-labs/dbt-core/issues/5625))
+- fix missing f-strings, convert old .format() messages to f-strings for consistency ([#6241](https://github.com/dbt-labs/dbt-core/issues/6241))
+- Clarify Error Message for how many models are allowed in a Python file ([#6245](https://github.com/dbt-labs/dbt-core/issues/6245))
+- Fix typo in util.py ([#4904](https://github.com/dbt-labs/dbt-core/issues/4904))
+- After this, will be possible to use default values for dbt.config.get ([#6309](https://github.com/dbt-labs/dbt-core/issues/6309))
+- Use full path for writing manifest ([#6055](https://github.com/dbt-labs/dbt-core/issues/6055))
+- add pre-commit install to make dev script in Makefile ([#6269](https://github.com/dbt-labs/dbt-core/issues/6269))
+- Late-rendering for `pre_` and `post_hook`s in `dbt_project.yml` ([#6411](https://github.com/dbt-labs/dbt-core/issues/6411))
+- [CT-1284] Change Python model default materialization to table ([#5989](https://github.com/dbt-labs/dbt-core/issues/5989))
+- [CT-1591] Don't parse empty Python files ([#6345](https://github.com/dbt-labs/dbt-core/issues/6345))
+- Repair a regression which prevented basic logging before the logging subsystem is completely configured. ([#6434](https://github.com/dbt-labs/dbt-core/issues/6434))
+- fix docs generate --defer by adding defer_to_manifest to before_run ([#6488](https://github.com/dbt-labs/dbt-core/issues/6488))
+- Bug when partial parsing with an empty schema file ([#4850](https://github.com/dbt-labs/dbt-core/issues/4850))
+- Fix DBT_FAVOR_STATE env var ([#5859](https://github.com/dbt-labs/dbt-core/issues/5859))
+- Restore historical behavior of certain disabled test messages, so that they are at the less obtrusive debug level, rather than the warning level. ([#6501](https://github.com/dbt-labs/dbt-core/issues/6501))
+- Bump mashumuro version to get regression fix and add unit test to verify that fix. ([#6428](https://github.com/dbt-labs/dbt-core/issues/6428))
+- Call update_event_status earlier for node results. Rename event 'HookFinished' -> FinishedRunningStats ([#6571](https://github.com/dbt-labs/dbt-core/issues/6571))
+- Provide backward compatibility for `get_merge_sql` arguments ([#6625](https://github.com/dbt-labs/dbt-core/issues/6625))
+- Fix behavior of --favor-state with --defer ([#6617](https://github.com/dbt-labs/dbt-core/issues/6617))
+- Include adapter_response in NodeFinished run_result log event ([#6703](https://github.com/dbt-labs/dbt-core/issues/6703))
+
+### Docs
+
+- minor doc correction ([dbt-docs/#5791](https://github.com/dbt-labs/dbt-docs/issues/5791))
+- Generate API docs for new CLI interface ([dbt-docs/#5528](https://github.com/dbt-labs/dbt-docs/issues/5528))
+-  ([dbt-docs/#5880](https://github.com/dbt-labs/dbt-docs/issues/5880))
+- Fix rendering of sample code for metrics ([dbt-docs/#323](https://github.com/dbt-labs/dbt-docs/issues/323))
+- Alphabetize `core/dbt/README.md` ([dbt-docs/#6368](https://github.com/dbt-labs/dbt-docs/issues/6368))
+- Updated minor typos encountered when skipping profile setup ([dbt-docs/#6529](https://github.com/dbt-labs/dbt-docs/issues/6529))
+
+### Under the Hood
+
+- Put black config in explicit config ([#5946](https://github.com/dbt-labs/dbt-core/issues/5946))
+- Added flat_graph attribute the Manifest class's deepcopy() coverage ([#5809](https://github.com/dbt-labs/dbt-core/issues/5809))
+- Add mypy configs so `mypy` passes from CLI ([#5983](https://github.com/dbt-labs/dbt-core/issues/5983))
+- Exception message cleanup. ([#6023](https://github.com/dbt-labs/dbt-core/issues/6023))
+- Add dmypy cache to gitignore ([#6028](https://github.com/dbt-labs/dbt-core/issues/6028))
+- Provide useful errors when the value of 'materialized' is invalid ([#5229](https://github.com/dbt-labs/dbt-core/issues/5229))
+- Clean up string formatting ([#6068](https://github.com/dbt-labs/dbt-core/issues/6068))
+- Fixed extra whitespace in strings introduced by black. ([#1350](https://github.com/dbt-labs/dbt-core/issues/1350))
+- Remove the 'root_path' field from most nodes ([#6171](https://github.com/dbt-labs/dbt-core/issues/6171))
+- Combine certain logging events with different levels ([#6173](https://github.com/dbt-labs/dbt-core/issues/6173))
+- Convert threading tests to pytest ([#5942](https://github.com/dbt-labs/dbt-core/issues/5942))
+- Convert postgres index tests to pytest ([#5770](https://github.com/dbt-labs/dbt-core/issues/5770))
+- Convert use color tests to pytest ([#5771](https://github.com/dbt-labs/dbt-core/issues/5771))
+- Add github actions workflow to generate high level CLI API docs ([#5942](https://github.com/dbt-labs/dbt-core/issues/5942))
+- Functionality-neutral refactor of event logging system to improve encapsulation and modularity. ([#6139](https://github.com/dbt-labs/dbt-core/issues/6139))
+- Consolidate ParsedNode and CompiledNode classes ([#6383](https://github.com/dbt-labs/dbt-core/issues/6383))
+- Prevent doc gen workflow from running on forks ([#6386](https://github.com/dbt-labs/dbt-core/issues/6386))
+- Fix intermittent database connection failure in Windows CI test ([#6394](https://github.com/dbt-labs/dbt-core/issues/6394))
+- Refactor and clean up manifest nodes ([#6426](https://github.com/dbt-labs/dbt-core/issues/6426))
+- Restore important legacy logging behaviors, following refactor which removed them ([#6437](https://github.com/dbt-labs/dbt-core/issues/6437))
+- Treat dense text blobs as binary for `git grep` ([#6294](https://github.com/dbt-labs/dbt-core/issues/6294))
+- Prune partial parsing logging events ([#6313](https://github.com/dbt-labs/dbt-core/issues/6313))
+- Updating the deprecation warning in the metric attributes renamed event ([#6507](https://github.com/dbt-labs/dbt-core/issues/6507))
+- [CT-1693] Port severity test to Pytest ([#6466](https://github.com/dbt-labs/dbt-core/issues/6466))
+- [CT-1694] Deprecate event tracking tests ([#6467](https://github.com/dbt-labs/dbt-core/issues/6467))
+- Reorganize structured logging events to have two top keys ([#6311](https://github.com/dbt-labs/dbt-core/issues/6311))
+- Combine some logging events ([#1716](https://github.com/dbt-labs/dbt-core/issues/1716), [#1717](https://github.com/dbt-labs/dbt-core/issues/1717), [#1719](https://github.com/dbt-labs/dbt-core/issues/1719))
+- Check length of escaped strings in the adapter test ([#6566](https://github.com/dbt-labs/dbt-core/issues/6566))
+
+### Dependencies
+
+- Update pathspec requirement from ~=0.9.0 to >=0.9,<0.11 in /core ([#5917](https://github.com/dbt-labs/dbt-core/pull/5917))
+- Bump black from 22.8.0 to 22.10.0 ([#6019](https://github.com/dbt-labs/dbt-core/pull/6019))
+- Bump mashumaro[msgpack] from 3.0.4 to 3.1.1 in /core ([#6108](https://github.com/dbt-labs/dbt-core/pull/6108))
+- Update colorama requirement from <0.4.6,>=0.3.9 to >=0.3.9,<0.4.7 in /core ([#6144](https://github.com/dbt-labs/dbt-core/pull/6144))
+- Bump mashumaro[msgpack] from 3.1.1 to 3.2 in /core ([#6375](https://github.com/dbt-labs/dbt-core/pull/6375))
+- Update agate requirement from <1.6.4,>=1.6 to >=1.6,<1.7.1 in /core ([#6506](https://github.com/dbt-labs/dbt-core/pull/6506))
+
+### Contributors
+- [@NiallRees](https://github.com/NiallRees) ([#5859](https://github.com/dbt-labs/dbt-core/issues/5859))
+- [@agpapa](https://github.com/agpapa) ([#6365](https://github.com/dbt-labs/dbt-core/issues/6365))
+- [@andy-clapson](https://github.com/andy-clapson) ([dbt-docs/#5791](https://github.com/dbt-labs/dbt-docs/issues/5791))
+- [@callum-mcdata](https://github.com/callum-mcdata) ([#6398](https://github.com/dbt-labs/dbt-core/issues/6398), [#6507](https://github.com/dbt-labs/dbt-core/issues/6507))
+- [@chamini2](https://github.com/chamini2) ([#6041](https://github.com/dbt-labs/dbt-core/issues/6041))
+- [@daniel-murray](https://github.com/daniel-murray) ([#5016](https://github.com/dbt-labs/dbt-core/issues/5016))
+- [@dave-connors-3](https://github.com/dave-connors-3) ([#5680](https://github.com/dbt-labs/dbt-core/issues/5680), [#5990](https://github.com/dbt-labs/dbt-core/issues/5990), [#6625](https://github.com/dbt-labs/dbt-core/issues/6625))
+- [@dbeatty10](https://github.com/dbeatty10) ([#6411](https://github.com/dbt-labs/dbt-core/issues/6411), [dbt-docs/#6368](https://github.com/dbt-labs/dbt-docs/issues/6368), [#6394](https://github.com/dbt-labs/dbt-core/issues/6394), [#6294](https://github.com/dbt-labs/dbt-core/issues/6294), [#6566](https://github.com/dbt-labs/dbt-core/issues/6566))
+- [@devmessias](https://github.com/devmessias) ([#6309](https://github.com/dbt-labs/dbt-core/issues/6309))
+- [@eltociear](https://github.com/eltociear) ([#4904](https://github.com/dbt-labs/dbt-core/issues/4904))
+- [@eve-johns](https://github.com/eve-johns) ([#6068](https://github.com/dbt-labs/dbt-core/issues/6068))
+- [@haritamar](https://github.com/haritamar) ([#6246](https://github.com/dbt-labs/dbt-core/issues/6246))
+- [@jared-rimmer](https://github.com/jared-rimmer) ([#5486](https://github.com/dbt-labs/dbt-core/issues/5486))
+- [@josephberni](https://github.com/josephberni) ([#5016](https://github.com/dbt-labs/dbt-core/issues/5016))
+- [@joshuataylor](https://github.com/joshuataylor) ([#6147](https://github.com/dbt-labs/dbt-core/issues/6147))
+- [@justbldwn](https://github.com/justbldwn) ([#6241](https://github.com/dbt-labs/dbt-core/issues/6241), [#6245](https://github.com/dbt-labs/dbt-core/issues/6245), [#6269](https://github.com/dbt-labs/dbt-core/issues/6269))
+- [@luke-bassett](https://github.com/luke-bassett) ([#1350](https://github.com/dbt-labs/dbt-core/issues/1350))
+- [@max-sixty](https://github.com/max-sixty) ([#5946](https://github.com/dbt-labs/dbt-core/issues/5946), [#5983](https://github.com/dbt-labs/dbt-core/issues/5983), [#6028](https://github.com/dbt-labs/dbt-core/issues/6028))
+- [@mivanicova](https://github.com/mivanicova) ([#6488](https://github.com/dbt-labs/dbt-core/issues/6488))
+- [@nshuman1](https://github.com/nshuman1) ([dbt-docs/#6529](https://github.com/dbt-labs/dbt-docs/issues/6529))
+- [@paulbenschmidt](https://github.com/paulbenschmidt) ([dbt-docs/#5880](https://github.com/dbt-labs/dbt-docs/issues/5880))
+- [@pgoslatara](https://github.com/pgoslatara) ([#5929](https://github.com/dbt-labs/dbt-core/issues/5929))
+- [@racheldaniel](https://github.com/racheldaniel) ([#6201](https://github.com/dbt-labs/dbt-core/issues/6201))
+- [@timle2](https://github.com/timle2) ([#4205](https://github.com/dbt-labs/dbt-core/issues/4205))
+- [@tmastny](https://github.com/tmastny) ([#6216](https://github.com/dbt-labs/dbt-core/issues/6216))
--- a/.changes/unreleased/Features-20230118-134804.yaml
+++ b/.changes/unreleased/Features-20230118-134804.yaml
@@ -1,6 +0,0 @@
-kind: Features
-body: Adding the entity node
-time: 2023-01-18T13:48:04.487817-06:00
-custom:
-  Author: callum-mcdata
-  Issue: "6627"
--- a/Hood-20230113-132513.yaml
+++ b/Hood-20230113-132513.yaml
@@ -1,6 +0,0 @@
-kind: Under the Hood
-body: Fix use of ConnectionReused logging event
-time: 2023-01-13T13:25:13.023168-05:00
-custom:
-  Author: gshank
-  Issue: "6168"
--- a/Hood-20230117-111737.yaml
+++ b/Hood-20230117-111737.yaml
@@ -1,6 +0,0 @@
-kind: Under the Hood
-body: Update deprecated github action command
-time: 2023-01-17T11:17:37.046095-06:00
-custom:
-  Author: davidbloss
-  Issue: "6153"
--- a/.flake8
+++ b/.flake8
@@ -9,4 +9,4 @@ ignore =
    E203 # makes Flake8 work like black
    E741
    E501 # long line checking is done in black
-exclude = test/
+exclude = test
--- a/.github/_README.md
+++ b/.github/_README.md
@@ -63,12 +63,12 @@ permissions:
  contents: read
  pull-requests: write
 ```
-
+    
 ### Secrets
 - When to use a [Personal Access Token (PAT)](https://docs.github.com/en/authentication/keeping-your-account-and-data-secure/creating-a-personal-access-token) vs the [GITHUB_TOKEN](https://docs.github.com/en/actions/security-guides/automatic-token-authentication) generated for the action?

    The `GITHUB_TOKEN` is used by default.  In most cases it is sufficient for what you need.
-
+    
    If you expect the workflow to result in a commit to that should retrigger workflows, you will need to use a Personal Access Token for the bot to commit the file. When using the GITHUB_TOKEN, the resulting commit will not trigger another GitHub Actions Workflow run. This is due to limitations set by GitHub. See [the docs](https://docs.github.com/en/actions/security-guides/automatic-token-authentication#using-the-github_token-in-a-workflow) for a more detailed explanation.

    For example, we must use a PAT in our workflow to commit a new changelog yaml file for bot PRs.  Once the file has been committed to the branch, it should retrigger the check to validate that a changelog exists on the PR.  Otherwise, it would stay in a failed state since the check would never retrigger.
@@ -105,7 +105,7 @@ Some triggers of note that we use:

  ```
  # **what?**
-  # Describe what the action does.
+  # Describe what the action does.  

  # **why?**
  # Why does this action exist?
@@ -138,7 +138,7 @@ Some triggers of note that we use:
        id: fp
        run: |
          FILEPATH=.changes/unreleased/Dependencies-${{ steps.filename_time.outputs.time }}.yaml
-          echo "FILEPATH=$FILEPATH" >> $GITHUB_OUTPUT
+          echo "::set-output name=FILEPATH::$FILEPATH"
  ```

 - Print out all variables you will reference as the first step of a job.  This allows for easier debugging.  The first job should log all inputs.  Subsequent jobs should reference outputs of other jobs, if present.
@@ -158,14 +158,14 @@ Some triggers of note that we use:
        echo "The build_script_path:              ${{ inputs.build_script_path }}"
        echo "The s3_bucket_name:                 ${{ inputs.s3_bucket_name }}"
        echo "The package_test_command:           ${{ inputs.package_test_command }}"
-
+      
    # collect all the variables that need to be used in subsequent jobs
    - name: Set Variables
      id: variables
      run: |
-        echo "important_path='performance/runner/Cargo.toml'" >> $GITHUB_OUTPUT
-        echo "release_id=${{github.event.inputs.release_id}}" >> $GITHUB_OUTPUT
-        echo "open_prs=${{github.event.inputs.open_prs}}" >> $GITHUB_OUTPUT
+        echo "::set-output name=important_path::'performance/runner/Cargo.toml'"
+        echo "::set-output name=release_id::${{github.event.inputs.release_id}}"
+        echo "::set-output name=open_prs::${{github.event.inputs.open_prs}}"

  job2:
    needs: [job1]
@@ -190,7 +190,7 @@ ___
 ### Actions from the Marketplace
 - Don’t use external actions for things that can easily be accomplished manually.
 - Always read through what an external action does before using it!  Often an action in the GitHub Actions Marketplace can be replaced with a few lines in bash.  This is much more maintainable (and won’t change under us) and clear as to what’s actually happening.  It also prevents any
- Pin actions _we don't control_ to tags.
+- Pin actions _we don't control_ to tags. 

 ### Connecting to AWS
 - Authenticate with the aws managed workflow
@@ -208,7 +208,7 @@ ___

  ```yaml
  - name: Copy Artifacts from S3 via CLI
-    run: aws s3 cp ${{ env.s3_bucket }} . --recursive
+    run: aws s3 cp ${{ env.s3_bucket }} . --recursive 
  ```

 ### Testing
--- a/.github/actions/latest-wrangler/main.py
+++ b/.github/actions/latest-wrangler/main.py
@@ -28,12 +28,11 @@ if __name__ == "__main__":
    if package_request.status_code == 404:
        if halt_on_missing:
            sys.exit(1)
-        # everything is the latest if the package doesn't exist
-        github_output = os.environ.get("GITHUB_OUTPUT")
-        with open(github_output, "at", encoding="utf-8") as gh_output:
-            gh_output.write("latest=True")
-            gh_output.write("minor_latest=True")
-        sys.exit(0)
+        else:
+            # everything is the latest if the package doesn't exist
+            print(f"::set-output name=latest::{True}")
+            print(f"::set-output name=minor_latest::{True}")
+            sys.exit(0)

    # TODO: verify package meta is "correct"
    # https://github.com/dbt-labs/dbt-core/issues/4640
@@ -92,7 +91,5 @@ if __name__ == "__main__":
    latest = is_latest(pre_rel, new_version, current_latest)
    minor_latest = is_latest(pre_rel, new_version, current_minor_latest)

-    github_output = os.environ.get("GITHUB_OUTPUT")
-    with open(github_output, "at", encoding="utf-8") as gh_output:
-        gh_output.write(f"latest={latest}")
-        gh_output.write(f"minor_latest={minor_latest}")
+    print(f"::set-output name=latest::{latest}")
+    print(f"::set-output name=minor_latest::{minor_latest}")
--- a/.github/workflows/main.yml
+++ b/.github/workflows/main.yml
@@ -101,9 +101,7 @@ jobs:
      - name: Get current date
        if: always()
        id: date
-        run: |
-          CURRENT_DATE=$(date +'%Y-%m-%dT%H_%M_%S') # no colons allowed for artifacts
-          echo "date=$CURRENT_DATE" >> $GITHUB_OUTPUT
+        run: echo "::set-output name=date::$(date +'%Y-%m-%dT%H_%M_%S')" #no colons allowed for artifacts

      - uses: actions/upload-artifact@v2
        if: always()
@@ -170,9 +168,7 @@ jobs:
      - name: Get current date
        if: always()
        id: date
-        run: |
-          CURRENT_DATE=$(date +'%Y-%m-%dT%H_%M_%S') # no colons allowed for artifacts
-          echo "date=$CURRENT_DATE" >> $GITHUB_OUTPUT
+        run: echo "::set-output name=date::$(date +'%Y_%m_%dT%H_%M_%S')" #no colons allowed for artifacts

      - uses: actions/upload-artifact@v2
        if: always()
--- a/.github/workflows/release-docker.yml
+++ b/.github/workflows/release-docker.yml
@@ -41,9 +41,9 @@ jobs:
        id: version
        run: |
          IFS="." read -r MAJOR MINOR PATCH <<< ${{ github.event.inputs.version_number }}
-          echo "major=$MAJOR" >> $GITHUB_OUTPUT
-          echo "minor=$MINOR" >> $GITHUB_OUTPUT
-          echo "patch=$PATCH" >> $GITHUB_OUTPUT
+          echo "::set-output name=major::$MAJOR"
+          echo "::set-output name=minor::$MINOR"
+          echo "::set-output name=patch::$PATCH"

      - name: Is pkg 'latest'
        id: latest
@@ -70,10 +70,8 @@ jobs:
      - name: Get docker build arg
        id: build_arg
        run: |
-          BUILD_ARG_NAME=$(echo ${{ github.event.inputs.package }} | sed 's/\-/_/g')
-          BUILD_ARG_VALUE=$(echo ${{ github.event.inputs.package }} | sed 's/postgres/core/g')
-          echo "build_arg_name=$BUILD_ARG_NAME" >> $GITHUB_OUTPUT
-          echo "build_arg_value=$BUILD_ARG_VALUE" >> $GITHUB_OUTPUT
+          echo "::set-output name=build_arg_name::"$(echo ${{ github.event.inputs.package }} | sed 's/\-/_/g')
+          echo "::set-output name=build_arg_value::"$(echo ${{ github.event.inputs.package }} | sed 's/postgres/core/g')

      - name: Log in to the GHCR
        uses: docker/login-action@v1
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -165,7 +165,7 @@ jobs:
        env:
          IS_PRERELEASE: ${{ contains(github.event.inputs.version_number, 'rc') ||  contains(github.event.inputs.version_number, 'b') }}
        run: |
-          echo "isPrerelease=$IS_PRERELEASE" >> $GITHUB_OUTPUT
+          echo ::set-output name=isPrerelease::$IS_PRERELEASE

      - name: Creating GitHub Release
        uses: softprops/action-gh-release@v1
--- a/.github/workflows/version-bump.yml
+++ b/.github/workflows/version-bump.yml
@@ -65,7 +65,7 @@ jobs:
      - name: Set branch value
        id: variables
        run: |
-          echo "BRANCH_NAME=prep-release/${{ github.event.inputs.version_number }}_$GITHUB_RUN_ID" >> $GITHUB_OUTPUT
+          echo "::set-output name=BRANCH_NAME::prep-release/${{ github.event.inputs.version_number }}_$GITHUB_RUN_ID"

      - name: Create PR branch
        run: |
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5,12 +5,139 @@
 - "Breaking changes" listed under a version may require action from end users or external maintainers when upgrading to that version.
 - Do not edit this file directly. This file is auto-generated using [changie](https://github.com/miniscruff/changie). For details on how to document a change, see [the contributing guide](https://github.com/dbt-labs/dbt-core/blob/main/CONTRIBUTING.md#adding-changelog-entry)

+## dbt-core 1.4.0 - January 25, 2023
+
+### Breaking Changes
+
+- Cleaned up exceptions to directly raise in code.  Also updated the existing exception to meet PEP guidelines.Removed use of all exception functions in the code base and marked them all as deprecated to be removed next minor release. ([#6339](https://github.com/dbt-labs/dbt-core/issues/6339), [#6393](https://github.com/dbt-labs/dbt-core/issues/6393), [#6460](https://github.com/dbt-labs/dbt-core/issues/6460))
+
+### Features
+
+- Added favor-state flag to optionally favor state nodes even if unselected node exists ([#5016](https://github.com/dbt-labs/dbt-core/issues/5016))
+- Update structured logging. Convert to using protobuf messages. Ensure events are enriched with node_info. ([#5610](https://github.com/dbt-labs/dbt-core/issues/5610))
+- incremental predicates ([#5680](https://github.com/dbt-labs/dbt-core/issues/5680))
+- Friendlier error messages when packages.yml is malformed ([#5486](https://github.com/dbt-labs/dbt-core/issues/5486))
+- Allow partitions in external tables to be supplied as a list ([#5929](https://github.com/dbt-labs/dbt-core/issues/5929))
+- extend -f flag shorthand for seed command ([#5990](https://github.com/dbt-labs/dbt-core/issues/5990))
+- This pulls the profile name from args when constructing a RuntimeConfig in lib.py, enabling the dbt-server to override the value that's in the dbt_project.yml ([#6201](https://github.com/dbt-labs/dbt-core/issues/6201))
+- Adding tarball install method for packages. Allowing package tarball to be specified via url in the packages.yaml. ([#4205](https://github.com/dbt-labs/dbt-core/issues/4205))
+- Added an md5 function to the base context ([#6246](https://github.com/dbt-labs/dbt-core/issues/6246))
+- Exposures support metrics in lineage ([#6057](https://github.com/dbt-labs/dbt-core/issues/6057))
+- Add support for Python 3.11 ([#6147](https://github.com/dbt-labs/dbt-core/issues/6147))
+- Making timestamp optional for metrics ([#6398](https://github.com/dbt-labs/dbt-core/issues/6398))
+- The meta configuration field is now included in the node_info property of structured logs. ([#6216](https://github.com/dbt-labs/dbt-core/issues/6216))
+- Adds buildable selection mode ([#6365](https://github.com/dbt-labs/dbt-core/issues/6365))
+- --warn-error-options: Treat warnings as errors for specific events, based on user configuration ([#6165](https://github.com/dbt-labs/dbt-core/issues/6165))
+
+### Fixes
+
+- Account for disabled flags on models in schema files more completely ([#3992](https://github.com/dbt-labs/dbt-core/issues/3992))
+- Add validation of enabled config for metrics, exposures and sources ([#6030](https://github.com/dbt-labs/dbt-core/issues/6030))
+- check length of args of python model function before accessing it ([#6041](https://github.com/dbt-labs/dbt-core/issues/6041))
+- Add functors to ensure event types with str-type attributes are initialized to spec, even when provided non-str type params. ([#5436](https://github.com/dbt-labs/dbt-core/issues/5436))
+- Allow hooks to fail without halting execution flow ([#5625](https://github.com/dbt-labs/dbt-core/issues/5625))
+- fix missing f-strings, convert old .format() messages to f-strings for consistency ([#6241](https://github.com/dbt-labs/dbt-core/issues/6241))
+- Clarify Error Message for how many models are allowed in a Python file ([#6245](https://github.com/dbt-labs/dbt-core/issues/6245))
+- Fix typo in util.py ([#4904](https://github.com/dbt-labs/dbt-core/issues/4904))
+- After this, will be possible to use default values for dbt.config.get ([#6309](https://github.com/dbt-labs/dbt-core/issues/6309))
+- Use full path for writing manifest ([#6055](https://github.com/dbt-labs/dbt-core/issues/6055))
+- add pre-commit install to make dev script in Makefile ([#6269](https://github.com/dbt-labs/dbt-core/issues/6269))
+- Late-rendering for `pre_` and `post_hook`s in `dbt_project.yml` ([#6411](https://github.com/dbt-labs/dbt-core/issues/6411))
+- [CT-1284] Change Python model default materialization to table ([#5989](https://github.com/dbt-labs/dbt-core/issues/5989))
+- [CT-1591] Don't parse empty Python files ([#6345](https://github.com/dbt-labs/dbt-core/issues/6345))
+- Repair a regression which prevented basic logging before the logging subsystem is completely configured. ([#6434](https://github.com/dbt-labs/dbt-core/issues/6434))
+- fix docs generate --defer by adding defer_to_manifest to before_run ([#6488](https://github.com/dbt-labs/dbt-core/issues/6488))
+- Bug when partial parsing with an empty schema file ([#4850](https://github.com/dbt-labs/dbt-core/issues/4850))
+- Fix DBT_FAVOR_STATE env var ([#5859](https://github.com/dbt-labs/dbt-core/issues/5859))
+- Restore historical behavior of certain disabled test messages, so that they are at the less obtrusive debug level, rather than the warning level. ([#6501](https://github.com/dbt-labs/dbt-core/issues/6501))
+- Bump mashumuro version to get regression fix and add unit test to verify that fix. ([#6428](https://github.com/dbt-labs/dbt-core/issues/6428))
+- Call update_event_status earlier for node results. Rename event 'HookFinished' -> FinishedRunningStats ([#6571](https://github.com/dbt-labs/dbt-core/issues/6571))
+- Provide backward compatibility for `get_merge_sql` arguments ([#6625](https://github.com/dbt-labs/dbt-core/issues/6625))
+- Fix behavior of --favor-state with --defer ([#6617](https://github.com/dbt-labs/dbt-core/issues/6617))
+- Include adapter_response in NodeFinished run_result log event ([#6703](https://github.com/dbt-labs/dbt-core/issues/6703))
+
+### Docs
+
+- minor doc correction ([dbt-docs/#5791](https://github.com/dbt-labs/dbt-docs/issues/5791))
+- Generate API docs for new CLI interface ([dbt-docs/#5528](https://github.com/dbt-labs/dbt-docs/issues/5528))
+-  ([dbt-docs/#5880](https://github.com/dbt-labs/dbt-docs/issues/5880))
+- Fix rendering of sample code for metrics ([dbt-docs/#323](https://github.com/dbt-labs/dbt-docs/issues/323))
+- Alphabetize `core/dbt/README.md` ([dbt-docs/#6368](https://github.com/dbt-labs/dbt-docs/issues/6368))
+- Updated minor typos encountered when skipping profile setup ([dbt-docs/#6529](https://github.com/dbt-labs/dbt-docs/issues/6529))
+
+### Under the Hood
+
+- Put black config in explicit config ([#5946](https://github.com/dbt-labs/dbt-core/issues/5946))
+- Added flat_graph attribute the Manifest class's deepcopy() coverage ([#5809](https://github.com/dbt-labs/dbt-core/issues/5809))
+- Add mypy configs so `mypy` passes from CLI ([#5983](https://github.com/dbt-labs/dbt-core/issues/5983))
+- Exception message cleanup. ([#6023](https://github.com/dbt-labs/dbt-core/issues/6023))
+- Add dmypy cache to gitignore ([#6028](https://github.com/dbt-labs/dbt-core/issues/6028))
+- Provide useful errors when the value of 'materialized' is invalid ([#5229](https://github.com/dbt-labs/dbt-core/issues/5229))
+- Clean up string formatting ([#6068](https://github.com/dbt-labs/dbt-core/issues/6068))
+- Fixed extra whitespace in strings introduced by black. ([#1350](https://github.com/dbt-labs/dbt-core/issues/1350))
+- Remove the 'root_path' field from most nodes ([#6171](https://github.com/dbt-labs/dbt-core/issues/6171))
+- Combine certain logging events with different levels ([#6173](https://github.com/dbt-labs/dbt-core/issues/6173))
+- Convert threading tests to pytest ([#5942](https://github.com/dbt-labs/dbt-core/issues/5942))
+- Convert postgres index tests to pytest ([#5770](https://github.com/dbt-labs/dbt-core/issues/5770))
+- Convert use color tests to pytest ([#5771](https://github.com/dbt-labs/dbt-core/issues/5771))
+- Add github actions workflow to generate high level CLI API docs ([#5942](https://github.com/dbt-labs/dbt-core/issues/5942))
+- Functionality-neutral refactor of event logging system to improve encapsulation and modularity. ([#6139](https://github.com/dbt-labs/dbt-core/issues/6139))
+- Consolidate ParsedNode and CompiledNode classes ([#6383](https://github.com/dbt-labs/dbt-core/issues/6383))
+- Prevent doc gen workflow from running on forks ([#6386](https://github.com/dbt-labs/dbt-core/issues/6386))
+- Fix intermittent database connection failure in Windows CI test ([#6394](https://github.com/dbt-labs/dbt-core/issues/6394))
+- Refactor and clean up manifest nodes ([#6426](https://github.com/dbt-labs/dbt-core/issues/6426))
+- Restore important legacy logging behaviors, following refactor which removed them ([#6437](https://github.com/dbt-labs/dbt-core/issues/6437))
+- Treat dense text blobs as binary for `git grep` ([#6294](https://github.com/dbt-labs/dbt-core/issues/6294))
+- Prune partial parsing logging events ([#6313](https://github.com/dbt-labs/dbt-core/issues/6313))
+- Updating the deprecation warning in the metric attributes renamed event ([#6507](https://github.com/dbt-labs/dbt-core/issues/6507))
+- [CT-1693] Port severity test to Pytest ([#6466](https://github.com/dbt-labs/dbt-core/issues/6466))
+- [CT-1694] Deprecate event tracking tests ([#6467](https://github.com/dbt-labs/dbt-core/issues/6467))
+- Reorganize structured logging events to have two top keys ([#6311](https://github.com/dbt-labs/dbt-core/issues/6311))
+- Combine some logging events ([#1716](https://github.com/dbt-labs/dbt-core/issues/1716), [#1717](https://github.com/dbt-labs/dbt-core/issues/1717), [#1719](https://github.com/dbt-labs/dbt-core/issues/1719))
+- Check length of escaped strings in the adapter test ([#6566](https://github.com/dbt-labs/dbt-core/issues/6566))
+
+### Dependencies
+
+- Update pathspec requirement from ~=0.9.0 to >=0.9,<0.11 in /core ([#5917](https://github.com/dbt-labs/dbt-core/pull/5917))
+- Bump black from 22.8.0 to 22.10.0 ([#6019](https://github.com/dbt-labs/dbt-core/pull/6019))
+- Bump mashumaro[msgpack] from 3.0.4 to 3.1.1 in /core ([#6108](https://github.com/dbt-labs/dbt-core/pull/6108))
+- Update colorama requirement from <0.4.6,>=0.3.9 to >=0.3.9,<0.4.7 in /core ([#6144](https://github.com/dbt-labs/dbt-core/pull/6144))
+- Bump mashumaro[msgpack] from 3.1.1 to 3.2 in /core ([#6375](https://github.com/dbt-labs/dbt-core/pull/6375))
+- Update agate requirement from <1.6.4,>=1.6 to >=1.6,<1.7.1 in /core ([#6506](https://github.com/dbt-labs/dbt-core/pull/6506))
+
+### Contributors
+- [@NiallRees](https://github.com/NiallRees) ([#5859](https://github.com/dbt-labs/dbt-core/issues/5859))
+- [@agpapa](https://github.com/agpapa) ([#6365](https://github.com/dbt-labs/dbt-core/issues/6365))
+- [@andy-clapson](https://github.com/andy-clapson) ([dbt-docs/#5791](https://github.com/dbt-labs/dbt-docs/issues/5791))
+- [@callum-mcdata](https://github.com/callum-mcdata) ([#6398](https://github.com/dbt-labs/dbt-core/issues/6398), [#6507](https://github.com/dbt-labs/dbt-core/issues/6507))
+- [@chamini2](https://github.com/chamini2) ([#6041](https://github.com/dbt-labs/dbt-core/issues/6041))
+- [@daniel-murray](https://github.com/daniel-murray) ([#5016](https://github.com/dbt-labs/dbt-core/issues/5016))
+- [@dave-connors-3](https://github.com/dave-connors-3) ([#5680](https://github.com/dbt-labs/dbt-core/issues/5680), [#5990](https://github.com/dbt-labs/dbt-core/issues/5990), [#6625](https://github.com/dbt-labs/dbt-core/issues/6625))
+- [@dbeatty10](https://github.com/dbeatty10) ([#6411](https://github.com/dbt-labs/dbt-core/issues/6411), [dbt-docs/#6368](https://github.com/dbt-labs/dbt-docs/issues/6368), [#6394](https://github.com/dbt-labs/dbt-core/issues/6394), [#6294](https://github.com/dbt-labs/dbt-core/issues/6294), [#6566](https://github.com/dbt-labs/dbt-core/issues/6566))
+- [@devmessias](https://github.com/devmessias) ([#6309](https://github.com/dbt-labs/dbt-core/issues/6309))
+- [@eltociear](https://github.com/eltociear) ([#4904](https://github.com/dbt-labs/dbt-core/issues/4904))
+- [@eve-johns](https://github.com/eve-johns) ([#6068](https://github.com/dbt-labs/dbt-core/issues/6068))
+- [@haritamar](https://github.com/haritamar) ([#6246](https://github.com/dbt-labs/dbt-core/issues/6246))
+- [@jared-rimmer](https://github.com/jared-rimmer) ([#5486](https://github.com/dbt-labs/dbt-core/issues/5486))
+- [@josephberni](https://github.com/josephberni) ([#5016](https://github.com/dbt-labs/dbt-core/issues/5016))
+- [@joshuataylor](https://github.com/joshuataylor) ([#6147](https://github.com/dbt-labs/dbt-core/issues/6147))
+- [@justbldwn](https://github.com/justbldwn) ([#6241](https://github.com/dbt-labs/dbt-core/issues/6241), [#6245](https://github.com/dbt-labs/dbt-core/issues/6245), [#6269](https://github.com/dbt-labs/dbt-core/issues/6269))
+- [@luke-bassett](https://github.com/luke-bassett) ([#1350](https://github.com/dbt-labs/dbt-core/issues/1350))
+- [@max-sixty](https://github.com/max-sixty) ([#5946](https://github.com/dbt-labs/dbt-core/issues/5946), [#5983](https://github.com/dbt-labs/dbt-core/issues/5983), [#6028](https://github.com/dbt-labs/dbt-core/issues/6028))
+- [@mivanicova](https://github.com/mivanicova) ([#6488](https://github.com/dbt-labs/dbt-core/issues/6488))
+- [@nshuman1](https://github.com/nshuman1) ([dbt-docs/#6529](https://github.com/dbt-labs/dbt-docs/issues/6529))
+- [@paulbenschmidt](https://github.com/paulbenschmidt) ([dbt-docs/#5880](https://github.com/dbt-labs/dbt-docs/issues/5880))
+- [@pgoslatara](https://github.com/pgoslatara) ([#5929](https://github.com/dbt-labs/dbt-core/issues/5929))
+- [@racheldaniel](https://github.com/racheldaniel) ([#6201](https://github.com/dbt-labs/dbt-core/issues/6201))
+- [@timle2](https://github.com/timle2) ([#4205](https://github.com/dbt-labs/dbt-core/issues/4205))
+- [@tmastny](https://github.com/tmastny) ([#6216](https://github.com/dbt-labs/dbt-core/issues/6216))
+
+
 ## Previous Releases

 For information on prior major and minor releases, see their changelogs:


-* [1.4](https://github.com/dbt-labs/dbt-core/blob/1.4.latest/CHANGELOG.md)
 * [1.3](https://github.com/dbt-labs/dbt-core/blob/1.3.latest/CHANGELOG.md)
 * [1.2](https://github.com/dbt-labs/dbt-core/blob/1.2.latest/CHANGELOG.md)
 * [1.1](https://github.com/dbt-labs/dbt-core/blob/1.1.latest/CHANGELOG.md)
--- a/core/dbt/adapters/base/connections.py
+++ b/core/dbt/adapters/base/connections.py
@@ -142,44 +142,44 @@ class BaseConnectionManager(metaclass=abc.ABCMeta):
        )

    def set_connection_name(self, name: Optional[str] = None) -> Connection:
-        """Called by 'acquire_connection' in BaseAdapter, which is called by
-        'connection_named', called by 'connection_for(node)'.
-        Creates a connection for this thread if one doesn't already
-        exist, and will rename an existing connection."""
+        conn_name: str
+        if name is None:
+            # if a name isn't specified, we'll re-use a single handle
+            # named 'master'
+            conn_name = "master"
+        else:
+            if not isinstance(name, str):
+                raise dbt.exceptions.CompilerException(
+                    f"For connection name, got {name} - not a string!"
+                )
+            assert isinstance(name, str)
+            conn_name = name

-        conn_name: str = "master" if name is None else name
-
-        # Get a connection for this thread
        conn = self.get_if_exists()
-
-        if conn and conn.name == conn_name and conn.state == "open":
-            # Found a connection and nothing to do, so just return it
-            return conn
-
        if conn is None:
-            # Create a new connection
            conn = Connection(
                type=Identifier(self.TYPE),
-                name=conn_name,
+                name=None,
                state=ConnectionState.INIT,
                transaction_open=False,
                handle=None,
                credentials=self.profile.credentials,
            )
-            conn.handle = LazyHandle(self.open)
-            # Add the connection to thread_connections for this thread
            self.set_thread_connection(conn)
-            fire_event(
-                NewConnection(conn_name=conn_name, conn_type=self.TYPE, node_info=get_node_info())
-            )
-        else:  # existing connection either wasn't open or didn't have the right name
-            if conn.state != "open":
-                conn.handle = LazyHandle(self.open)
-            if conn.name != conn_name:
-                orig_conn_name: str = conn.name or ""
-                conn.name = conn_name
-                fire_event(ConnectionReused(orig_conn_name=orig_conn_name, conn_name=conn_name))

+        if conn.name == conn_name and conn.state == "open":
+            return conn
+
+        fire_event(
+            NewConnection(conn_name=conn_name, conn_type=self.TYPE, node_info=get_node_info())
+        )
+
+        if conn.state == "open":
+            fire_event(ConnectionReused(conn_name=conn_name))
+        else:
+            conn.handle = LazyHandle(self.open)
+
+        conn.name = conn_name
        return conn

    @classmethod
--- a/core/dbt/compilation.py
+++ b/core/dbt/compilation.py
@@ -48,7 +48,6 @@ def print_compile_stats(stats):
        NodeType.Source: "source",
        NodeType.Exposure: "exposure",
        NodeType.Metric: "metric",
-        NodeType.Entity: "entity",
    }

    results = {k: 0 for k in names.keys()}
@@ -84,8 +83,6 @@ def _generate_stats(manifest: Manifest):
        stats[exposure.resource_type] += 1
    for metric in manifest.metrics.values():
        stats[metric.resource_type] += 1
-    for entity in manifest.entities.values():
-        stats[entity.resource_type] += 1
    for macro in manifest.macros.values():
        stats[macro.resource_type] += 1
    return stats
@@ -401,8 +398,6 @@ class Compiler:
                linker.dependency(node.unique_id, (manifest.sources[dependency].unique_id))
            elif dependency in manifest.metrics:
                linker.dependency(node.unique_id, (manifest.metrics[dependency].unique_id))
-            elif dependency in manifest.entities:
-                linker.dependency(node.unique_id, (manifest.entities[dependency].unique_id))
            else:
                raise GraphDependencyNotFoundError(node, dependency)

@@ -415,8 +410,6 @@ class Compiler:
            self.link_node(linker, exposure, manifest)
        for metric in manifest.metrics.values():
            self.link_node(linker, metric, manifest)
-        for entity in manifest.entities.values():
-            self.link_node(linker, entity, manifest)

        cycle = linker.find_cycles()

--- a/core/dbt/config/project.py
+++ b/core/dbt/config/project.py
@@ -381,7 +381,6 @@ class PartialProject(RenderComponents):
        sources: Dict[str, Any]
        tests: Dict[str, Any]
        metrics: Dict[str, Any]
-        entities: Dict[str, Any]
        exposures: Dict[str, Any]
        vars_value: VarProvider

@@ -392,7 +391,6 @@ class PartialProject(RenderComponents):
        sources = cfg.sources
        tests = cfg.tests
        metrics = cfg.metrics
-        entities = cfg.entities
        exposures = cfg.exposures
        if cfg.vars is None:
            vars_dict: Dict[str, Any] = {}
@@ -448,7 +446,6 @@ class PartialProject(RenderComponents):
            sources=sources,
            tests=tests,
            metrics=metrics,
-            entities=entities,
            exposures=exposures,
            vars=vars_value,
            config_version=cfg.config_version,
@@ -553,7 +550,6 @@ class Project:
    sources: Dict[str, Any]
    tests: Dict[str, Any]
    metrics: Dict[str, Any]
-    entities: Dict[str, Any]
    exposures: Dict[str, Any]
    vars: VarProvider
    dbt_version: List[VersionSpecifier]
@@ -628,7 +624,6 @@ class Project:
                "sources": self.sources,
                "tests": self.tests,
                "metrics": self.metrics,
-                "entities": self.entities,
                "exposures": self.exposures,
                "vars": self.vars.to_dict(),
                "require-dbt-version": [v.to_version_string() for v in self.dbt_version],
--- a/core/dbt/config/runtime.py
+++ b/core/dbt/config/runtime.py
@@ -117,7 +117,6 @@ class RuntimeConfig(Project, Profile, AdapterRequiredConfig):
            sources=project.sources,
            tests=project.tests,
            metrics=project.metrics,
-            entities=project.entities,
            exposures=project.exposures,
            vars=project.vars,
            config_version=project.config_version,
@@ -313,7 +312,6 @@ class RuntimeConfig(Project, Profile, AdapterRequiredConfig):
            "sources": self._get_config_paths(self.sources),
            "tests": self._get_config_paths(self.tests),
            "metrics": self._get_config_paths(self.metrics),
-            "entities": self._get_config_paths(self.entities),
            "exposures": self._get_config_paths(self.exposures),
        }

@@ -502,7 +500,6 @@ class UnsetProfileConfig(RuntimeConfig):
                "sources": self.sources,
                "tests": self.tests,
                "metrics": self.metrics,
-                "entities": self.entities,
                "exposures": self.exposures,
                "vars": self.vars.to_dict(),
                "require-dbt-version": [v.to_version_string() for v in self.dbt_version],
@@ -565,7 +562,6 @@ class UnsetProfileConfig(RuntimeConfig):
            sources=project.sources,
            tests=project.tests,
            metrics=project.metrics,
-            entities=project.entities,
            exposures=project.exposures,
            vars=project.vars,
            config_version=project.config_version,
--- a/core/dbt/context/context_config.py
+++ b/core/dbt/context/context_config.py
@@ -45,8 +45,6 @@ class UnrenderedConfig(ConfigSource):
            model_configs = unrendered.get("tests")
        elif resource_type == NodeType.Metric:
            model_configs = unrendered.get("metrics")
-        elif resource_type == NodeType.Entity:
-            model_configs = unrendered.get("entities")
        elif resource_type == NodeType.Exposure:
            model_configs = unrendered.get("exposures")
        else:
@@ -72,8 +70,6 @@ class RenderedConfig(ConfigSource):
            model_configs = self.project.tests
        elif resource_type == NodeType.Metric:
            model_configs = self.project.metrics
-        elif resource_type == NodeType.Entity:
-            model_configs = self.project.entities
        elif resource_type == NodeType.Exposure:
            model_configs = self.project.exposures
        else:
--- a/core/dbt/context/providers.py
+++ b/core/dbt/context/providers.py
@@ -33,7 +33,6 @@ from dbt.contracts.graph.nodes import (
    Macro,
    Exposure,
    Metric,
-    Entity,
    SeedNode,
    SourceDefinition,
    Resource,
@@ -1505,44 +1504,6 @@ def generate_parse_metrics(
    }


-class EntityRefResolver(BaseResolver):
-    def __call__(self, *args) -> str:
-        package = None
-        if len(args) == 1:
-            name = args[0]
-        elif len(args) == 2:
-            package, name = args
-        else:
-            raise RefArgsError(node=self.model, args=args)
-        self.validate_args(name, package)
-        self.model.refs.append(list(args))
-        return ""
-
-    def validate_args(self, name, package):
-        if not isinstance(name, str):
-            raise ParsingError(
-                f"In the entity associated with {self.model.original_file_path} "
-                "the name argument to ref() must be a string"
-            )
-
-
-def generate_parse_entities(
-    entity: Entity,
-    config: RuntimeConfig,
-    manifest: Manifest,
-    package_name: str,
-) -> Dict[str, Any]:
-    project = config.load_dependencies()[package_name]
-    return {
-        "ref": EntityRefResolver(
-            None,
-            entity,
-            project,
-            manifest,
-        ),
-    }
-
-
 # This class is currently used by the schema parser in order
 # to limit the number of macros in the context by using
 # the TestMacroNamespace
--- a/core/dbt/contracts/files.py
+++ b/core/dbt/contracts/files.py
@@ -227,7 +227,6 @@ class SchemaSourceFile(BaseSourceFile):
    sources: List[str] = field(default_factory=list)
    exposures: List[str] = field(default_factory=list)
    metrics: List[str] = field(default_factory=list)
-    entities: List[str] = field(default_factory=list)
    # node patches contain models, seeds, snapshots, analyses
    ndp: List[str] = field(default_factory=list)
    # any macro patches in this file by macro unique_id.
--- a/core/dbt/contracts/graph/manifest.py
+++ b/core/dbt/contracts/graph/manifest.py
@@ -29,7 +29,6 @@ from dbt.contracts.graph.nodes import (
    GenericTestNode,
    Exposure,
    Metric,
-    Entity,
    UnpatchedSourceDefinition,
    ManifestNode,
    GraphMemberNode,
@@ -213,39 +212,6 @@ class MetricLookup(dbtClassMixin):
        return manifest.metrics[unique_id]


-class EntityLookup(dbtClassMixin):
-    def __init__(self, manifest: "Manifest"):
-        self.storage: Dict[str, Dict[PackageName, UniqueID]] = {}
-        self.populate(manifest)
-
-    def get_unique_id(self, search_name, package: Optional[PackageName]):
-        return find_unique_id_for_package(self.storage, search_name, package)
-
-    def find(self, search_name, package: Optional[PackageName], manifest: "Manifest"):
-        unique_id = self.get_unique_id(search_name, package)
-        if unique_id is not None:
-            return self.perform_lookup(unique_id, manifest)
-        return None
-
-    def add_entity(self, entity: Entity):
-        if entity.search_name not in self.storage:
-            self.storage[entity.search_name] = {}
-
-        self.storage[entity.search_name][entity.package_name] = entity.unique_id
-
-    def populate(self, manifest):
-        for entity in manifest.entities.values():
-            if hasattr(entity, "name"):
-                self.add_entity(entity)
-
-    def perform_lookup(self, unique_id: UniqueID, manifest: "Manifest") -> Entity:
-        if unique_id not in manifest.entities:
-            raise dbt.exceptions.DbtInternalError(
-                f"Entity {unique_id} found in cache but not found in manifest"
-            )
-        return manifest.entities[unique_id]
-
-
 # This handles both models/seeds/snapshots and sources/metrics/exposures
 class DisabledLookup(dbtClassMixin):
    def __init__(self, manifest: "Manifest"):
@@ -490,9 +456,6 @@ class Disabled(Generic[D]):
 MaybeMetricNode = Optional[Union[Metric, Disabled[Metric]]]


-MaybeEntityNode = Optional[Union[Entity, Disabled[Entity]]]
-
-
 MaybeDocumentation = Optional[Documentation]


@@ -636,7 +599,6 @@ class Manifest(MacroMethods, DataClassMessagePackMixin, dbtClassMixin):
    docs: MutableMapping[str, Documentation] = field(default_factory=dict)
    exposures: MutableMapping[str, Exposure] = field(default_factory=dict)
    metrics: MutableMapping[str, Metric] = field(default_factory=dict)
-    entities: MutableMapping[str, Entity] = field(default_factory=dict)
    selectors: MutableMapping[str, Any] = field(default_factory=dict)
    files: MutableMapping[str, AnySourceFile] = field(default_factory=dict)
    metadata: ManifestMetadata = field(default_factory=ManifestMetadata)
@@ -658,9 +620,6 @@ class Manifest(MacroMethods, DataClassMessagePackMixin, dbtClassMixin):
    _metric_lookup: Optional[MetricLookup] = field(
        default=None, metadata={"serialize": lambda x: None, "deserialize": lambda x: None}
    )
-    _entity_lookup: Optional[EntityLookup] = field(
-        default=None, metadata={"serialize": lambda x: None, "deserialize": lambda x: None}
-    )
    _disabled_lookup: Optional[DisabledLookup] = field(
        default=None, metadata={"serialize": lambda x: None, "deserialize": lambda x: None}
    )
@@ -711,9 +670,6 @@ class Manifest(MacroMethods, DataClassMessagePackMixin, dbtClassMixin):
    def update_metric(self, new_metric: Metric):
        _update_into(self.metrics, new_metric)

-    def update_entity(self, new_entity: Entity):
-        _update_into(self.entities, new_entity)
-
    def update_node(self, new_node: ManifestNode):
        _update_into(self.nodes, new_node)

@@ -729,7 +685,6 @@ class Manifest(MacroMethods, DataClassMessagePackMixin, dbtClassMixin):
        self.flat_graph = {
            "exposures": {k: v.to_dict(omit_none=False) for k, v in self.exposures.items()},
            "metrics": {k: v.to_dict(omit_none=False) for k, v in self.metrics.items()},
-            "entities": {k: v.to_dict(omit_none=False) for k, v in self.entities.items()},
            "nodes": {k: v.to_dict(omit_none=False) for k, v in self.nodes.items()},
            "sources": {k: v.to_dict(omit_none=False) for k, v in self.sources.items()},
        }
@@ -792,7 +747,6 @@ class Manifest(MacroMethods, DataClassMessagePackMixin, dbtClassMixin):
            self.nodes.values(),
            self.sources.values(),
            self.metrics.values(),
-            self.entities.values(),
        )
        for resource in all_resources:
            resource_type_plural = resource.resource_type.pluralize()
@@ -821,7 +775,6 @@ class Manifest(MacroMethods, DataClassMessagePackMixin, dbtClassMixin):
            docs={k: _deepcopy(v) for k, v in self.docs.items()},
            exposures={k: _deepcopy(v) for k, v in self.exposures.items()},
            metrics={k: _deepcopy(v) for k, v in self.metrics.items()},
-            entities={k: _deepcopy(v) for k, v in self.entities.items()},
            selectors={k: _deepcopy(v) for k, v in self.selectors.items()},
            metadata=self.metadata,
            disabled={k: _deepcopy(v) for k, v in self.disabled.items()},
@@ -838,7 +791,6 @@ class Manifest(MacroMethods, DataClassMessagePackMixin, dbtClassMixin):
                self.sources.values(),
                self.exposures.values(),
                self.metrics.values(),
-                self.entities.values(),
            )
        )
        forward_edges, backward_edges = build_node_edges(edge_members)
@@ -864,7 +816,6 @@ class Manifest(MacroMethods, DataClassMessagePackMixin, dbtClassMixin):
            docs=self.docs,
            exposures=self.exposures,
            metrics=self.metrics,
-            entities=self.entities,
            selectors=self.selectors,
            metadata=self.metadata,
            disabled=self.disabled,
@@ -886,8 +837,6 @@ class Manifest(MacroMethods, DataClassMessagePackMixin, dbtClassMixin):
            return self.exposures[unique_id]
        elif unique_id in self.metrics:
            return self.metrics[unique_id]
-        elif unique_id in self.entities:
-            return self.entities[unique_id]
        else:
            # something terrible has happened
            raise dbt.exceptions.DbtInternalError(
@@ -924,12 +873,6 @@ class Manifest(MacroMethods, DataClassMessagePackMixin, dbtClassMixin):
            self._metric_lookup = MetricLookup(self)
        return self._metric_lookup

-    @property
-    def entity_lookup(self) -> EntityLookup:
-        if self._entity_lookup is None:
-            self._entity_lookup = EntityLookup(self)
-        return self._entity_lookup
-
    def rebuild_ref_lookup(self):
        self._ref_lookup = RefableLookup(self)

@@ -1030,31 +973,6 @@ class Manifest(MacroMethods, DataClassMessagePackMixin, dbtClassMixin):
            return Disabled(disabled[0])
        return None

-    def resolve_entity(
-        self,
-        target_entity_name: str,
-        target_entity_package: Optional[str],
-        current_project: str,
-        node_package: str,
-    ) -> MaybeEntityNode:
-
-        entity: Optional[Entity] = None
-        disabled: Optional[List[Entity]] = None
-
-        candidates = _search_packages(current_project, node_package, target_entity_package)
-        for pkg in candidates:
-            entity = self.entity_lookup.find(target_entity_name, pkg, self)
-
-            if entity is not None and entity.config.enabled:
-                return entity
-
-            # it's possible that the node is disabled
-            if disabled is None:
-                disabled = self.disabled_lookup.find(f"{target_entity_name}", pkg)
-        if disabled:
-            return Disabled(disabled[0])
-        return None
-
    # Called by DocsRuntimeContext.doc
    def resolve_doc(
        self,
@@ -1165,11 +1083,6 @@ class Manifest(MacroMethods, DataClassMessagePackMixin, dbtClassMixin):
        self.metrics[metric.unique_id] = metric
        source_file.metrics.append(metric.unique_id)

-    def add_entity(self, source_file: SchemaSourceFile, entity: Entity):
-        _check_duplicates(entity, self.entities)
-        self.entities[entity.unique_id] = entity
-        source_file.entities.append(entity.unique_id)
-
    def add_disabled_nofile(self, node: GraphMemberNode):
        # There can be multiple disabled nodes for the same unique_id
        if node.unique_id in self.disabled:
@@ -1185,8 +1098,6 @@ class Manifest(MacroMethods, DataClassMessagePackMixin, dbtClassMixin):
                source_file.add_test(node.unique_id, test_from)
            if isinstance(node, Metric):
                source_file.metrics.append(node.unique_id)
-            if isinstance(node, Entity):
-                source_file.entities.append(node.unique_id)
            if isinstance(node, Exposure):
                source_file.exposures.append(node.unique_id)
        else:
@@ -1214,7 +1125,6 @@ class Manifest(MacroMethods, DataClassMessagePackMixin, dbtClassMixin):
            self.docs,
            self.exposures,
            self.metrics,
-            self.entities,
            self.selectors,
            self.files,
            self.metadata,
@@ -1227,7 +1137,6 @@ class Manifest(MacroMethods, DataClassMessagePackMixin, dbtClassMixin):
            self._source_lookup,
            self._ref_lookup,
            self._metric_lookup,
-            self._entity_lookup,
            self._disabled_lookup,
            self._analysis_lookup,
        )
@@ -1269,9 +1178,6 @@ class WritableManifest(ArtifactMixin):
    metrics: Mapping[UniqueID, Metric] = field(
        metadata=dict(description=("The metrics defined in the dbt project and its dependencies"))
    )
-    entities: Mapping[UniqueID, Entity] = field(
-        metadata=dict(description=("The entities defined in the dbt project and its dependencies"))
-    )
    selectors: Mapping[UniqueID, Any] = field(
        metadata=dict(description=("The selectors defined in selectors.yml"))
    )
@@ -1296,8 +1202,7 @@ class WritableManifest(ArtifactMixin):

    @classmethod
    def compatible_previous_versions(self):
-        # return [("manifest", 4), ("manifest", 5), ("manifest", 6), ("manifest", 7)]
-        return []
+        return [("manifest", 4), ("manifest", 5), ("manifest", 6), ("manifest", 7)]

    def __post_serialize__(self, dct):
        for unique_id, node in dct["nodes"].items():
--- a/core/dbt/contracts/graph/model_config.py
+++ b/core/dbt/contracts/graph/model_config.py
@@ -368,11 +368,6 @@ class MetricConfig(BaseConfig):
    enabled: bool = True


-@dataclass
-class EntityConfig(BaseConfig):
-    enabled: bool = True
-
-
@dataclass
 class ExposureConfig(BaseConfig):
    enabled: bool = True
@@ -609,7 +604,6 @@ class SnapshotConfig(EmptySnapshotConfig):

 RESOURCE_TYPES: Dict[NodeType, Type[BaseConfig]] = {
    NodeType.Metric: MetricConfig,
-    NodeType.Entity: EntityConfig,
    NodeType.Exposure: ExposureConfig,
    NodeType.Source: SourceConfig,
    NodeType.Seed: SeedConfig,
--- a/core/dbt/contracts/graph/nodes.py
+++ b/core/dbt/contracts/graph/nodes.py
@@ -55,7 +55,6 @@ from .model_config import (
    TestConfig,
    SourceConfig,
    MetricConfig,
-    EntityConfig,
    ExposureConfig,
    EmptySnapshotConfig,
    SnapshotConfig,
@@ -273,7 +272,7 @@ class ParsedNode(NodeInfoMixin, ParsedNodeMandatory, SerializableType):
    @classmethod
    def _deserialize(cls, dct: Dict[str, int]):
        # The serialized ParsedNodes do not differ from each other
-        # in fields that would allow 'from_dict' to distinguish
+        # in fields that would allow 'from_dict' to distinguis
        # between them.
        resource_type = dct["resource_type"]
        if resource_type == "model":
@@ -393,7 +392,6 @@ class CompiledNode(ParsedNode):
    refs: List[List[str]] = field(default_factory=list)
    sources: List[List[str]] = field(default_factory=list)
    metrics: List[List[str]] = field(default_factory=list)
-    entities: List[List[str]] = field(default_factory=list)
    depends_on: DependsOn = field(default_factory=DependsOn)
    compiled_path: Optional[str] = None
    compiled: bool = False
@@ -908,7 +906,6 @@ class Exposure(GraphNode):
    refs: List[List[str]] = field(default_factory=list)
    sources: List[List[str]] = field(default_factory=list)
    metrics: List[List[str]] = field(default_factory=list)
-    entities: List[List[str]] = field(default_factory=list)
    created_at: float = field(default_factory=lambda: time.time())

    @property
@@ -1000,7 +997,6 @@ class Metric(GraphNode):
    depends_on: DependsOn = field(default_factory=DependsOn)
    refs: List[List[str]] = field(default_factory=list)
    metrics: List[List[str]] = field(default_factory=list)
-    entities: List[List[str]] = field(default_factory=list)
    created_at: float = field(default_factory=lambda: time.time())

    @property
@@ -1069,63 +1065,6 @@ class Metric(GraphNode):
        )


-@dataclass
-class Entity(GraphNode):
-    name: str
-    model: str
-    description: str
-    dimensions: List[str]
-    resource_type: NodeType = field(metadata={"restrict": [NodeType.Entity]})
-    model_unique_id: Optional[str] = None
-    meta: Dict[str, Any] = field(default_factory=dict)
-    tags: List[str] = field(default_factory=list)
-    config: EntityConfig = field(default_factory=EntityConfig)
-    unrendered_config: Dict[str, Any] = field(default_factory=dict)
-    sources: List[List[str]] = field(default_factory=list)
-    depends_on: DependsOn = field(default_factory=DependsOn)
-    refs: List[List[str]] = field(default_factory=list)
-    entities: List[List[str]] = field(default_factory=list)
-    metrics: List[List[str]] = field(default_factory=list)
-    created_at: float = field(default_factory=lambda: time.time())
-
-    @property
-    def depends_on_nodes(self):
-        return self.depends_on.nodes
-
-    @property
-    def search_name(self):
-        return self.name
-
-    def same_model(self, old: "Entity") -> bool:
-        return self.model == old.model
-
-    def same_dimensions(self, old: "Entity") -> bool:
-        return self.dimensions == old.dimensions
-
-    def same_description(self, old: "Entity") -> bool:
-        return self.description == old.description
-
-    def same_config(self, old: "Entity") -> bool:
-        return self.config.same_contents(
-            self.unrendered_config,
-            old.unrendered_config,
-        )
-
-    def same_contents(self, old: Optional["Entity"]) -> bool:
-        # existing when it didn't before is a change!
-        # metadata/tags changes are not "changes"
-        if old is None:
-            return True
-
-        return (
-            self.same_model(old)
-            and self.same_dimensions(old)
-            and self.same_description(old)
-            and self.same_config(old)
-            and True
-        )
-
-
 # ====================================
 # Patches
 # ====================================
@@ -1187,7 +1126,6 @@ GraphMemberNode = Union[
    ResultNode,
    Exposure,
    Metric,
-    Entity,
 ]

 # All "nodes" (or node-like objects) in this file
--- a/core/dbt/contracts/graph/unparsed.py
+++ b/core/dbt/contracts/graph/unparsed.py
@@ -533,21 +533,3 @@ class UnparsedMetric(dbtClassMixin, Replaceable):

        if data.get("model") is not None and data.get("calculation_method") == "derived":
            raise ValidationError("Derived metrics cannot have a 'model' property")
-
-
-@dataclass
-class UnparsedEntity(dbtClassMixin, Replaceable):
-    """This class is used for entity information"""
-
-    name: str
-    model: str
-    description: str = ""
-    dimensions: List[str] = field(default_factory=list)
-    meta: Dict[str, Any] = field(default_factory=dict)
-    tags: List[str] = field(default_factory=list)
-    config: Dict[str, Any] = field(default_factory=dict)
-
-    @classmethod
-    def validate(cls, data):
-        super(UnparsedEntity, cls).validate(data)
-        # TODO: Add validation here around include/exclude and others
--- a/core/dbt/contracts/project.py
+++ b/core/dbt/contracts/project.py
@@ -214,7 +214,6 @@ class Project(HyphenatedDbtClassMixin, Replaceable):
    sources: Dict[str, Any] = field(default_factory=dict)
    tests: Dict[str, Any] = field(default_factory=dict)
    metrics: Dict[str, Any] = field(default_factory=dict)
-    entities: Dict[str, Any] = field(default_factory=dict)
    exposures: Dict[str, Any] = field(default_factory=dict)
    vars: Optional[Dict[str, Any]] = field(
        default=None,
--- a/core/dbt/contracts/results.py
+++ b/core/dbt/contracts/results.py
@@ -13,7 +13,7 @@ from dbt.events.types import TimingInfoCollected
 from dbt.events.proto_types import RunResultMsg, TimingInfoMsg
 from dbt.events.contextvars import get_node_info
 from dbt.logger import TimingProcessor
-from dbt.utils import lowercase, cast_to_str, cast_to_int
+from dbt.utils import lowercase, cast_to_str, cast_to_int, cast_dict_to_dict_of_strings
 from dbt.dataclass_schema import dbtClassMixin, StrEnum

 import agate
@@ -130,7 +130,6 @@ class BaseResult(dbtClassMixin):
        return data

    def to_msg(self):
-        # TODO: add more fields
        msg = RunResultMsg()
        msg.status = str(self.status)
        msg.message = cast_to_str(self.message)
@@ -138,7 +137,7 @@ class BaseResult(dbtClassMixin):
        msg.execution_time = self.execution_time
        msg.num_failures = cast_to_int(self.failures)
        msg.timing_info = [ti.to_msg() for ti in self.timing]
-        # adapter_response
+        msg.adapter_response = cast_dict_to_dict_of_strings(self.adapter_response)
        return msg


--- a/core/dbt/events/proto_types.py
+++ b/core/dbt/events/proto_types.py
@@ -531,7 +531,6 @@ class ConnectionReused(betterproto.Message):
    """E006"""

    conn_name: str = betterproto.string_field(1)
-    orig_conn_name: str = betterproto.string_field(2)


@dataclass
--- a/core/dbt/events/types.proto
+++ b/core/dbt/events/types.proto
@@ -419,7 +419,6 @@ message NewConnectionMsg {
 // E006
 message ConnectionReused {
    string conn_name = 1;
-    string orig_conn_name = 2;
 }

 message ConnectionReusedMsg {
--- a/core/dbt/events/types.py
+++ b/core/dbt/events/types.py
@@ -449,7 +449,7 @@ class ConnectionReused(DebugLevel, pt.ConnectionReused):
        return "E006"

    def message(self) -> str:
-        return f"Re-using an available connection from the pool (formerly {self.orig_conn_name}, now {self.conn_name})"
+        return f"Re-using an available connection from the pool (formerly {self.conn_name})"


@dataclass
--- a/core/dbt/graph/cli.py
+++ b/core/dbt/graph/cli.py
@@ -20,7 +20,7 @@ from .selector_spec import (

 INTERSECTION_DELIMITER = ","

-DEFAULT_INCLUDES: List[str] = ["fqn:*", "source:*", "exposure:*", "metric:*", "entity:*"]
+DEFAULT_INCLUDES: List[str] = ["fqn:*", "source:*", "exposure:*", "metric:*"]
 DEFAULT_EXCLUDES: List[str] = []


--- a/core/dbt/graph/queue.py
+++ b/core/dbt/graph/queue.py
@@ -9,7 +9,6 @@ from dbt.contracts.graph.nodes import (
    SourceDefinition,
    Exposure,
    Metric,
-    Entity,
    GraphMemberNode,
 )
 from dbt.contracts.graph.manifest import Manifest
@@ -52,8 +51,8 @@ class GraphQueue:
        node = self.manifest.expect(node_id)
        if node.resource_type != NodeType.Model:
            return False
-        # must be a Model - tell mypy this won't be a Source or Exposure or Metric or Entity
-        assert not isinstance(node, (SourceDefinition, Exposure, Metric, Entity))
+        # must be a Model - tell mypy this won't be a Source or Exposure or Metric
+        assert not isinstance(node, (SourceDefinition, Exposure, Metric))
        if node.is_ephemeral:
            return False
        return True
--- a/core/dbt/graph/selector.py
+++ b/core/dbt/graph/selector.py
@@ -163,9 +163,6 @@ class NodeSelector(MethodManager):
        elif unique_id in self.manifest.metrics:
            metric = self.manifest.metrics[unique_id]
            return metric.config.enabled
-        elif unique_id in self.manifest.entities:
-            entity = self.manifest.entities[unique_id]
-            return entity.config.enabled
        node = self.manifest.nodes[unique_id]
        return not node.empty and node.config.enabled

@@ -185,8 +182,6 @@ class NodeSelector(MethodManager):
            node = self.manifest.exposures[unique_id]
        elif unique_id in self.manifest.metrics:
            node = self.manifest.metrics[unique_id]
-        elif unique_id in self.manifest.entities:
-            node = self.manifest.entities[unique_id]
        else:
            raise DbtInternalError(f"Node {unique_id} not found in the manifest!")
        return self.node_is_match(node)
--- a/core/dbt/graph/selector_methods.py
+++ b/core/dbt/graph/selector_methods.py
@@ -12,7 +12,6 @@ from dbt.contracts.graph.nodes import (
    SingularTestNode,
    Exposure,
    Metric,
-    Entity,
    GenericTestNode,
    SourceDefinition,
    ResultNode,
@@ -44,7 +43,6 @@ class MethodName(StrEnum):
    State = "state"
    Exposure = "exposure"
    Metric = "metric"
-    Entity = "entity"
    Result = "result"
    SourceStatus = "source_status"

@@ -73,7 +71,7 @@ def is_selected_node(fqn: List[str], node_selector: str):
    return True


-SelectorTarget = Union[SourceDefinition, ManifestNode, Exposure, Metric, Entity]
+SelectorTarget = Union[SourceDefinition, ManifestNode, Exposure, Metric]


 class SelectorMethod(metaclass=abc.ABCMeta):
@@ -120,14 +118,6 @@ class SelectorMethod(metaclass=abc.ABCMeta):
                continue
            yield unique_id, metric

-    def entity_nodes(self, included_nodes: Set[UniqueId]) -> Iterator[Tuple[UniqueId, Entity]]:
-
-        for key, metric in self.manifest.entities.items():
-            unique_id = UniqueId(key)
-            if unique_id not in included_nodes:
-                continue
-            yield unique_id, metric
-
    def all_nodes(
        self, included_nodes: Set[UniqueId]
    ) -> Iterator[Tuple[UniqueId, SelectorTarget]]:
@@ -136,7 +126,6 @@ class SelectorMethod(metaclass=abc.ABCMeta):
            self.source_nodes(included_nodes),
            self.exposure_nodes(included_nodes),
            self.metric_nodes(included_nodes),
-            self.entity_nodes(included_nodes),
        )

    def configurable_nodes(
@@ -147,12 +136,11 @@ class SelectorMethod(metaclass=abc.ABCMeta):
    def non_source_nodes(
        self,
        included_nodes: Set[UniqueId],
-    ) -> Iterator[Tuple[UniqueId, Union[Exposure, ManifestNode, Metric, Entity]]]:
+    ) -> Iterator[Tuple[UniqueId, Union[Exposure, ManifestNode, Metric]]]:
        yield from chain(
            self.parsed_nodes(included_nodes),
            self.exposure_nodes(included_nodes),
            self.metric_nodes(included_nodes),
-            self.entity_nodes(included_nodes),
        )

    @abc.abstractmethod
@@ -282,33 +270,6 @@ class MetricSelectorMethod(SelectorMethod):
            yield node


-class EntitySelectorMethod(SelectorMethod):
-    """TODO: Add a description of what this selector method is doing"""
-
-    def search(self, included_nodes: Set[UniqueId], selector: str) -> Iterator[UniqueId]:
-        parts = selector.split(".")
-        target_package = SELECTOR_GLOB
-        if len(parts) == 1:
-            target_name = parts[0]
-        elif len(parts) == 2:
-            target_package, target_name = parts
-        else:
-            msg = (
-                'Invalid entity selector value "{}". Entities must be of '
-                "the form ${{entity_name}} or "
-                "${{entity_package.entity_name}}"
-            ).format(selector)
-            raise DbtRuntimeError(msg)
-
-        for node, real_node in self.entity_nodes(included_nodes):
-            if target_package not in (real_node.package_name, SELECTOR_GLOB):
-                continue
-            if target_name not in (real_node.name, SELECTOR_GLOB):
-                continue
-
-            yield node
-
-
 class PathSelectorMethod(SelectorMethod):
    def search(self, included_nodes: Set[UniqueId], selector: str) -> Iterator[UniqueId]:
        """Yields nodes from included that match the given path."""
@@ -569,8 +530,6 @@ class StateSelectorMethod(SelectorMethod):
                previous_node = manifest.exposures[node]
            elif node in manifest.metrics:
                previous_node = manifest.metrics[node]
-            elif node in manifest.entities:
-                previous_node = manifest.entities[node]

            if checker(previous_node, real_node):
                yield node
@@ -657,7 +616,6 @@ class MethodManager:
        MethodName.State: StateSelectorMethod,
        MethodName.Exposure: ExposureSelectorMethod,
        MethodName.Metric: MetricSelectorMethod,
-        MethodName.Entity: EntitySelectorMethod,
        MethodName.Result: ResultSelectorMethod,
        MethodName.SourceStatus: SourceStatusSelectorMethod,
    }
--- a/core/dbt/include/global_project/macros/materializations/models/incremental/merge.sql
+++ b/core/dbt/include/global_project/macros/materializations/models/incremental/merge.sql
@@ -1,8 +1,10 @@
-{% macro get_merge_sql(target, source, unique_key, dest_columns, incremental_predicates) -%}
+{% macro get_merge_sql(target, source, unique_key, dest_columns, incremental_predicates=none) -%}
+   -- back compat for old kwarg name
+  {% set incremental_predicates = kwargs.get('predicates', incremental_predicates) %}
  {{ adapter.dispatch('get_merge_sql', 'dbt')(target, source, unique_key, dest_columns, incremental_predicates) }}
 {%- endmacro %}

-{% macro default__get_merge_sql(target, source, unique_key, dest_columns, incremental_predicates) -%}
+{% macro default__get_merge_sql(target, source, unique_key, dest_columns, incremental_predicates=none) -%}
    {%- set predicates = [] if incremental_predicates is none else [] + incremental_predicates -%}
    {%- set dest_cols_csv = get_quoted_csv(dest_columns | map(attribute="name")) -%}
    {%- set merge_update_columns = config.get('merge_update_columns') -%}
--- a/core/dbt/main.py
+++ b/core/dbt/main.py
@@ -486,7 +486,7 @@ def _build_snapshot_subparser(subparsers, base_subparser):
    return sub


-def _add_defer_argument(*subparsers):
+def _add_defer_arguments(*subparsers):
    for sub in subparsers:
        sub.add_optional_argument_inverse(
            "--defer",
@@ -499,10 +499,6 @@ def _add_defer_argument(*subparsers):
            """,
            default=flags.DEFER_MODE,
        )
-
-
-def _add_favor_state_argument(*subparsers):
-    for sub in subparsers:
        sub.add_optional_argument_inverse(
            "--favor-state",
            enable_help="""
@@ -580,7 +576,7 @@ def _build_docs_generate_subparser(subparsers, base_subparser):
        Do not run "dbt compile" as part of docs generation
        """,
    )
-    _add_defer_argument(generate_sub)
+    _add_defer_arguments(generate_sub)
    return generate_sub


@@ -1192,9 +1188,7 @@ def parse_args(args, cls=DBTArgumentParser):
    # list_sub sets up its own arguments.
    _add_selection_arguments(run_sub, compile_sub, generate_sub, test_sub, snapshot_sub, seed_sub)
    # --defer
-    _add_defer_argument(run_sub, test_sub, build_sub, snapshot_sub, compile_sub)
-    # --favor-state
-    _add_favor_state_argument(run_sub, test_sub, build_sub, snapshot_sub)
+    _add_defer_arguments(run_sub, test_sub, build_sub, snapshot_sub, compile_sub)
    # --full-refresh
    _add_table_mutability_arguments(run_sub, compile_sub, build_sub)

--- a/core/dbt/node_types.py
+++ b/core/dbt/node_types.py
@@ -18,7 +18,6 @@ class NodeType(StrEnum):
    Macro = "macro"
    Exposure = "exposure"
    Metric = "metric"
-    Entity = "entity"

    @classmethod
    def executable(cls) -> List["NodeType"]:
@@ -53,14 +52,11 @@ class NodeType(StrEnum):
            cls.Analysis,
            cls.Exposure,
            cls.Metric,
-            cls.Entity,
        ]

    def pluralize(self) -> str:
        if self is self.Analysis:
            return "analyses"
-        if self is self.Entity:
-            return "entities"
        return f"{self}s"


--- a/core/dbt/parser/generic_test_builders.py
+++ b/core/dbt/parser/generic_test_builders.py
@@ -272,7 +272,7 @@ class TestBuilder(Generic[Testable]):
                        column_name=column_name,
                        name=self.name,
                        key=key,
-                        err_msg=e.msg,
+                        err_msg=e.msg
                    )

            if value is not None:
--- a/core/dbt/parser/manifest.py
+++ b/core/dbt/parser/manifest.py
@@ -56,7 +56,6 @@ from dbt.contracts.graph.nodes import (
    ColumnInfo,
    Exposure,
    Metric,
-    Entity,
    SeedNode,
    ManifestNode,
    ResultNode,
@@ -341,7 +340,7 @@ class ManifestLoader:
                    project, project_parser_files[project.project_name], parser_types
                )

-            # Now that we've loaded most of the nodes (except for schema tests, sources, metrics, entities)
+            # Now that we've loaded most of the nodes (except for schema tests, sources, metrics)
            # load up the Lookup objects to resolve them by name, so the SourceFiles store
            # the unique_id instead of the name. Sources are loaded from yaml files, so
            # aren't in place yet
@@ -377,7 +376,7 @@ class ManifestLoader:
            # copy the selectors from the root_project to the manifest
            self.manifest.selectors = self.root_project.manifest_selectors

-            # update the refs, sources, docs, entities and metrics depends_on.nodes
+            # update the refs, sources, docs and metrics depends_on.nodes
            # These check the created_at time on the nodes to
            # determine whether they need processing.
            start_process = time.perf_counter()
@@ -385,7 +384,6 @@ class ManifestLoader:
            self.process_refs(self.root_project.project_name)
            self.process_docs(self.root_project)
            self.process_metrics(self.root_project)
-            self.process_entities(self.root_project)

            # update tracking data
            self._perf_info.process_manifest_elapsed = time.perf_counter() - start_process
@@ -840,10 +838,6 @@ class ManifestLoader:
            if metric.created_at < self.started_at:
                continue
            _process_refs_for_metric(self.manifest, current_project, metric)
-        for entity in self.manifest.entities.values():
-            if entity.created_at < self.started_at:
-                continue
-            _process_refs_for_entity(self.manifest, current_project, entity)

    # Takes references in 'metrics' array of nodes and exposures, finds the target
    # node, and updates 'depends_on.nodes' with the unique id
@@ -864,23 +858,6 @@ class ManifestLoader:
                continue
            _process_metrics_for_node(self.manifest, current_project, exposure)

-    # Takes references in 'entities' array of nodes and exposures, finds the target
-    # node, and updates 'depends_on.nodes' with the unique id
-    def process_entities(self, config: RuntimeConfig):
-        current_project = config.project_name
-        for node in self.manifest.nodes.values():
-            if node.created_at < self.started_at:
-                continue
-            _process_entities_for_node(self.manifest, current_project, node)
-        for entity in self.manifest.entities.values():
-            if entity.created_at < self.started_at:
-                continue
-            _process_entities_for_node(self.manifest, current_project, entity)
-        for exposure in self.manifest.exposures.values():
-            if exposure.created_at < self.started_at:
-                continue
-            _process_entities_for_node(self.manifest, current_project, exposure)
-
    # nodes: node and column descriptions
    # sources: source and table descriptions, column descriptions
    # macros: macro argument descriptions
@@ -936,16 +913,6 @@ class ManifestLoader:
                config.project_name,
            )
            _process_docs_for_metrics(ctx, metric)
-        for entity in self.manifest.entities.values():
-            if entity.created_at < self.started_at:
-                continue
-            ctx = generate_runtime_docs_context(
-                config,
-                entity,
-                self.manifest,
-                config.project_name,
-            )
-            _process_docs_for_entities(ctx, entity)

    # Loops through all nodes and exposures, for each element in
    # 'sources' array finds the source node and updates the
@@ -1136,10 +1103,6 @@ def _process_docs_for_metrics(context: Dict[str, Any], metric: Metric) -> None:
    metric.description = get_rendered(metric.description, context)


-def _process_docs_for_entities(context: Dict[str, Any], entity: Entity) -> None:
-    entity.description = get_rendered(entity.description, context)
-
-
 def _process_refs_for_exposure(manifest: Manifest, current_project: str, exposure: Exposure):
    """Given a manifest and exposure in that manifest, process its refs"""
    for ref in exposure.refs:
@@ -1227,48 +1190,6 @@ def _process_refs_for_metric(manifest: Manifest, current_project: str, metric: M
        manifest.update_metric(metric)


-def _process_refs_for_entity(manifest: Manifest, current_project: str, entity: Entity):
-    """Given a manifest and an entity in that manifest, process its refs"""
-    for ref in entity.refs:
-        target_model: Optional[Union[Disabled, ManifestNode]] = None
-        target_model_name: str
-        target_model_package: Optional[str] = None
-
-        if len(ref) == 1:
-            target_model_name = ref[0]
-        elif len(ref) == 2:
-            target_model_package, target_model_name = ref
-        else:
-            raise dbt.exceptions.DbtInternalError(
-                f"Refs should always be 1 or 2 arguments - got {len(ref)}"
-            )
-
-        target_model = manifest.resolve_ref(
-            target_model_name,
-            target_model_package,
-            current_project,
-            entity.package_name,
-        )
-
-        if target_model is None or isinstance(target_model, Disabled):
-            # This may raise. Even if it doesn't, we don't want to add
-            # this entity to the graph b/c there is no destination entity
-            entity.config.enabled = False
-            invalid_target_fail_unless_test(
-                node=entity,
-                target_name=target_model_name,
-                target_kind="node",
-                target_package=target_model_package,
-                disabled=(isinstance(target_model, Disabled)),
-            )
-            continue
-
-        target_model_id = target_model.unique_id
-
-        entity.depends_on.nodes.append(target_model_id)
-        manifest.update_entity(entity)
-
-
 def _process_metrics_for_node(
    manifest: Manifest,
    current_project: str,
@@ -1318,55 +1239,6 @@ def _process_metrics_for_node(
        node.depends_on.nodes.append(target_metric_id)


-def _process_entities_for_node(
-    manifest: Manifest,
-    current_project: str,
-    node: Union[ManifestNode, Entity, Exposure],
-):
-    """Given a manifest and a node in that manifest, process its entities"""
-
-    if isinstance(node, SeedNode):
-        return
-
-    for entity in node.entities:
-        target_entity: Optional[Union[Disabled, Entity]] = None
-        target_entity_name: str
-        target_entity_package: Optional[str] = None
-
-        if len(entity) == 1:
-            target_entity_name = entity[0]
-        elif len(entity) == 2:
-            target_entity_package, target_entity_name = entity
-        else:
-            raise dbt.exceptions.DbtInternalError(
-                f"Entity references should always be 1 or 2 arguments - got {len(entity)}"
-            )
-
-        target_entity = manifest.resolve_entity(
-            target_entity_name,
-            target_entity_package,
-            current_project,
-            node.package_name,
-        )
-
-        if target_entity is None or isinstance(target_entity, Disabled):
-            # This may raise. Even if it doesn't, we don't want to add
-            # this node to the graph b/c there is no destination node
-            node.config.enabled = False
-            invalid_target_fail_unless_test(
-                node=node,
-                target_name=target_entity_name,
-                target_kind="source",
-                target_package=target_entity_package,
-                disabled=(isinstance(target_entity, Disabled)),
-            )
-            continue
-
-        target_entity_id = target_entity.unique_id
-
-        node.depends_on.nodes.append(target_entity_id)
-
-
 def _process_refs_for_node(manifest: Manifest, current_project: str, node: ManifestNode):
    """Given a manifest and a node in that manifest, process its refs"""

@@ -1441,7 +1313,6 @@ def _process_sources_for_exposure(manifest: Manifest, current_project: str, expo
        manifest.update_exposure(exposure)


-# TODO: Remove this code because metrics can't be based on sources
 def _process_sources_for_metric(manifest: Manifest, current_project: str, metric: Metric):
    target_source: Optional[Union[Disabled, SourceDefinition]] = None
    for source_name, table_name in metric.sources:
--- a/core/dbt/parser/partial.py
+++ b/core/dbt/parser/partial.py
@@ -8,7 +8,6 @@ from dbt.contracts.files import (
    parse_file_type_to_parser,
 )
 from dbt.events.functions import fire_event
-from dbt.events.base_types import EventLevel
 from dbt.events.types import (
    PartialParsingEnabled,
    PartialParsingFile,
@@ -156,11 +155,7 @@ class PartialParsing:
            self.macro_child_map = self.saved_manifest.build_macro_child_map()
        deleted = len(deleted) + len(deleted_schema_files)
        changed = len(changed) + len(changed_schema_files)
-        event = PartialParsingEnabled(deleted=deleted, added=len(added), changed=changed)
-        if os.environ.get("DBT_PP_TEST"):
-            fire_event(event, level=EventLevel.INFO)
-        else:
-            fire_event(event)
+        fire_event(PartialParsingEnabled(deleted=deleted, added=len(added), changed=changed))
        self.file_diff = file_diff

    # generate the list of files that need parsing
@@ -242,7 +237,7 @@ class PartialParsing:
                    self.remove_source_override_target(source)

    def delete_disabled(self, unique_id, file_id):
-        # This node/metric/entity/exposure is disabled. Find it and remove it from disabled dictionary.
+        # This node/metric/exposure is disabled. Find it and remove it from disabled dictionary.
        for dis_index, dis_node in enumerate(self.saved_manifest.disabled[unique_id]):
            if dis_node.file_id == file_id:
                node = dis_node
@@ -441,18 +436,6 @@ class PartialParsing:
                    if metric_element:
                        self.delete_schema_metric(schema_file, metric_element)
                        self.merge_patch(schema_file, "metrics", metric_element)
-            elif unique_id in self.saved_manifest.entities:
-                entity = self.saved_manifest.entities[unique_id]
-                file_id = entity.file_id
-                if file_id in self.saved_files and file_id not in self.file_diff["deleted"]:
-                    schema_file = self.saved_files[file_id]
-                    entities = []
-                    if "entities" in schema_file.dict_from_yaml:
-                        entities = schema_file.dict_from_yaml["entities"]
-                    entity_element = self.get_schema_element(entities, entity.name)
-                    if entity_element:
-                        self.delete_schema_entity(schema_file, entity_element)
-                        self.merge_patch(schema_file, "entities", entity_element)
            elif unique_id in self.saved_manifest.macros:
                macro = self.saved_manifest.macros[unique_id]
                file_id = macro.file_id
@@ -758,29 +741,6 @@ class PartialParsing:
                    self.delete_schema_metric(schema_file, elem)
                    self.merge_patch(schema_file, dict_key, elem)

-        # entities
-        dict_key = "entities"
-        entity_diff = self.get_diff_for("entities", saved_yaml_dict, new_yaml_dict)
-        if entity_diff["changed"]:
-            for entity in entity_diff["changed"]:
-                self.delete_schema_entity(schema_file, entity)
-                self.merge_patch(schema_file, dict_key, entity)
-        if entity_diff["deleted"]:
-            for entity in entity_diff["deleted"]:
-                self.delete_schema_entity(schema_file, entity)
-        if entity_diff["added"]:
-            for entity in entity_diff["added"]:
-                self.merge_patch(schema_file, dict_key, entity)
-        # Handle schema file updates due to env_var changes
-        if dict_key in env_var_changes and dict_key in new_yaml_dict:
-            for name in env_var_changes[dict_key]:
-                if name in entity_diff["changed_or_deleted_names"]:
-                    continue
-                elem = self.get_schema_element(new_yaml_dict[dict_key], name)
-                if elem:
-                    self.delete_schema_entity(schema_file, elem)
-                    self.merge_patch(schema_file, dict_key, elem)
-
    # Take a "section" of the schema file yaml dictionary from saved and new schema files
    # and determine which parts have changed
    def get_diff_for(self, key, saved_yaml_dict, new_yaml_dict):
@@ -956,24 +916,6 @@ class PartialParsing:
            elif unique_id in self.saved_manifest.disabled:
                self.delete_disabled(unique_id, schema_file.file_id)

-    # entities are created only from schema files, but also can be referred to by other nodes
-    def delete_schema_entity(self, schema_file, entity_dict):
-        entity_name = entity_dict["name"]
-        entities = schema_file.entities.copy()
-        for unique_id in entities:
-            if unique_id in self.saved_manifest.entities:
-                entity = self.saved_manifest.entities[unique_id]
-                if entity.name == entity_name:
-                    # Need to find everything that referenced this entity and schedule for parsing
-                    if unique_id in self.saved_manifest.child_map:
-                        self.schedule_nodes_for_parsing(self.saved_manifest.child_map[unique_id])
-                    self.deleted_manifest.entities[unique_id] = self.saved_manifest.entities.pop(
-                        unique_id
-                    )
-                    schema_file.entities.remove(unique_id)
-            elif unique_id in self.saved_manifest.disabled:
-                self.delete_disabled(unique_id, schema_file.file_id)
-
    def get_schema_element(self, elem_list, elem_name):
        for element in elem_list:
            if "name" in element and element["name"] == elem_name:
--- a/core/dbt/parser/schemas.py
+++ b/core/dbt/parser/schemas.py
@@ -22,12 +22,11 @@ from dbt.context.configured import generate_schema_yml_context, SchemaYamlVars
 from dbt.context.providers import (
    generate_parse_exposure,
    generate_parse_metrics,
-    generate_parse_entities,
    generate_test_context,
 )
 from dbt.context.macro_resolver import MacroResolver
 from dbt.contracts.files import FileHash, SchemaSourceFile
-from dbt.contracts.graph.model_config import MetricConfig, ExposureConfig, EntityConfig
+from dbt.contracts.graph.model_config import MetricConfig, ExposureConfig
 from dbt.contracts.graph.nodes import (
    ParsedNodePatch,
    ColumnInfo,
@@ -36,7 +35,6 @@ from dbt.contracts.graph.nodes import (
    UnpatchedSourceDefinition,
    Exposure,
    Metric,
-    Entity,
 )
 from dbt.contracts.graph.unparsed import (
    HasColumnDocs,
@@ -49,7 +47,6 @@ from dbt.contracts.graph.unparsed import (
    UnparsedNodeUpdate,
    UnparsedExposure,
    UnparsedMetric,
-    UnparsedEntity,
    UnparsedSourceDefinition,
 )
 from dbt.exceptions import (
@@ -97,7 +94,6 @@ schema_file_keys = (
    "analyses",
    "exposures",
    "metrics",
-    "entities",
 )


@@ -118,7 +114,6 @@ class ParserRef:
    def __init__(self):
        self.column_info: Dict[str, ColumnInfo] = {}

-    # TODO: Mimic this for dimension information at the entity level
    def add(
        self,
        column: Union[HasDocs, UnparsedColumn],
@@ -541,11 +536,6 @@ class SchemaParser(SimpleParser[GenericTestBlock, GenericTestNode]):
                metric_parser = MetricParser(self, yaml_block)
                metric_parser.parse()

-            # parse entities
-            if "entities" in dct:
-                entity_parser = EntityParser(self, yaml_block)
-                entity_parser.parse()
-

 def check_format_version(file_path, yaml_dct) -> None:
    if "version" not in yaml_dct:
@@ -1193,107 +1183,3 @@ class MetricParser(YamlReader):
            except (ValidationError, JSONValidationError) as exc:
                raise YamlParseDictError(self.yaml.path, self.key, data, exc)
            self.parse_metric(unparsed)
-
-
-class EntityParser(YamlReader):
-    def __init__(self, schema_parser: SchemaParser, yaml: YamlBlock):
-        super().__init__(schema_parser, yaml, NodeType.Entity.pluralize())
-        self.schema_parser = schema_parser
-        self.yaml = yaml
-
-    def parse_entity(self, unparsed: UnparsedEntity):
-        package_name = self.project.project_name
-        unique_id = f"{NodeType.Entity}.{package_name}.{unparsed.name}"
-        path = self.yaml.path.relative_path
-
-        fqn = self.schema_parser.get_fqn_prefix(path)
-        fqn.append(unparsed.name)
-
-        config = self._generate_entity_config(
-            target=unparsed,
-            fqn=fqn,
-            package_name=package_name,
-            rendered=True,
-        )
-
-        config = config.finalize_and_validate()
-
-        unrendered_config = self._generate_entity_config(
-            target=unparsed,
-            fqn=fqn,
-            package_name=package_name,
-            rendered=False,
-        )
-
-        if not isinstance(config, EntityConfig):
-            raise DbtInternalError(
-                f"Calculated a {type(config)} for an entity, but expected a EntityConfig"
-            )
-
-        parsed = Entity(
-            resource_type=NodeType.Entity,
-            package_name=package_name,
-            path=path,
-            original_file_path=self.yaml.path.original_file_path,
-            unique_id=unique_id,
-            fqn=fqn,
-            model=unparsed.model,
-            name=unparsed.name,
-            description=unparsed.description,
-            dimensions=unparsed.dimensions,
-            meta=unparsed.meta,
-            tags=unparsed.tags,
-            config=config,
-            unrendered_config=unrendered_config,
-        )
-
-        ctx = generate_parse_entities(
-            parsed,
-            self.root_project,
-            self.schema_parser.manifest,
-            package_name,
-        )
-
-        if parsed.model is not None:
-            model_ref = "{{ " + parsed.model + " }}"
-            get_rendered(model_ref, ctx, parsed)
-
-        # if the metric is disabled we do not want it included in the manifest, only in the disabled dict
-        if parsed.config.enabled:
-            # self.manifest.add_metric(self.yaml.file, parsed)
-            self.manifest.add_entity(self.yaml.file, parsed)
-        else:
-            self.manifest.add_disabled(self.yaml.file, parsed)
-
-    def _generate_entity_config(
-        self, target: UnparsedEntity, fqn: List[str], package_name: str, rendered: bool
-    ):
-        generator: BaseContextConfigGenerator
-        if rendered:
-            generator = ContextConfigGenerator(self.root_project)
-        else:
-            generator = UnrenderedConfigGenerator(self.root_project)
-
-        # configs with precendence set
-        precedence_configs = dict()
-        # first apply metric configs
-        precedence_configs.update(target.config)
-
-        return generator.calculate_node_config(
-            config_call_dict={},
-            fqn=fqn,
-            resource_type=NodeType.Entity,
-            project_name=package_name,
-            base=False,
-            patch_config_dict=precedence_configs,
-        )
-
-    def parse(self):
-        for data in self.get_key_dicts():
-            try:
-                UnparsedEntity.validate(data)
-                unparsed = UnparsedEntity.from_dict(data)
-
-            except (ValidationError, JSONValidationError) as exc:
-                raise YamlParseDictError(self.yaml.path, self.key, data, exc)
-            self.parse_entity(unparsed)
--- a/core/dbt/task/compile.py
+++ b/core/dbt/task/compile.py
@@ -83,6 +83,7 @@ class CompileTask(GraphRunnableTask):
            adapter=adapter,
            other=deferred_manifest,
            selected=selected_uids,
+            favor_state=bool(self.args.favor_state),
        )
        # TODO: is it wrong to write the manifest here? I think it's right...
        self.write_manifest()
--- a/core/dbt/task/list.py
+++ b/core/dbt/task/list.py
@@ -1,6 +1,6 @@
 import json

-from dbt.contracts.graph.nodes import Exposure, SourceDefinition, Metric, Entity
+from dbt.contracts.graph.nodes import Exposure, SourceDefinition, Metric
 from dbt.graph import ResourceTypeSelector
 from dbt.task.runnable import GraphRunnableTask, ManifestTask
 from dbt.task.test import TestSelector
@@ -22,7 +22,6 @@ class ListTask(GraphRunnableTask):
            NodeType.Source,
            NodeType.Exposure,
            NodeType.Metric,
-            NodeType.Entity,
        )
    )
    ALL_RESOURCE_VALUES = DEFAULT_RESOURCE_VALUES | frozenset((NodeType.Analysis,))
@@ -83,8 +82,6 @@ class ListTask(GraphRunnableTask):
                yield self.manifest.exposures[node]
            elif node in self.manifest.metrics:
                yield self.manifest.metrics[node]
-            elif node in self.manifest.entities:
-                yield self.manifest.entities[node]
            else:
                raise DbtRuntimeError(
                    f'Got an unexpected result from node selection: "{node}"'
@@ -108,11 +105,6 @@ class ListTask(GraphRunnableTask):
                # metrics are searched for by pkg.metric_name
                metric_selector = ".".join([node.package_name, node.name])
                yield f"metric:{metric_selector}"
-            elif node.resource_type == NodeType.Entity:
-                assert isinstance(node, Entity)
-                # entities are searched for by pkg.entity_name
-                entity_selector = ".".join([node.package_name, node.name])
-                yield f"entity:{entity_selector}"
            else:
                # everything else is from `fqn`
                yield ".".join(node.fqn)
--- a/core/dbt/task/test.py
+++ b/core/dbt/task/test.py
@@ -91,7 +91,9 @@ class TestRunner(CompileRunner):
    def before_execute(self):
        self.print_start_line()

-    def execute_test(self, test: TestNode, manifest: Manifest) -> TestResultData:
+    def execute_test(
+        self, test: TestNode, manifest: Manifest
+    ) -> TestResultData:
        context = generate_runtime_model_context(test, self.config, manifest)

        materialization_macro = manifest.find_materialization_macro_by_name(
@@ -99,9 +101,7 @@ class TestRunner(CompileRunner):
        )

        if materialization_macro is None:
-            raise MissingMaterializationError(
-                materialization=test.get_materialization(), adapter_type=self.adapter.type()
-            )
+            raise MissingMaterializationError(materialization=test.get_materialization(), adapter_type=self.adapter.type())

        if "config" not in context:
            raise DbtInternalError(
--- a/core/dbt/tests/fixtures/project.py
+++ b/core/dbt/tests/fixtures/project.py
@@ -249,9 +249,7 @@ def clean_up_logging():
 # otherwise this will fail. So to test errors in those areas, you need to copy the files
 # into the project in the tests instead of putting them in the fixtures.
@pytest.fixture(scope="class")
-def adapter(
-    unique_schema, project_root, profiles_root, profiles_yml, dbt_project_yml, clean_up_logging
-):
+def adapter(unique_schema, project_root, profiles_root, profiles_yml, dbt_project_yml, clean_up_logging):
    # The profiles.yml and dbt_project.yml should already be written out
    args = Namespace(
        profiles_dir=str(profiles_root), project_dir=str(project_root), target=None, profile=None
--- a/core/dbt/tests/util.py
+++ b/core/dbt/tests/util.py
@@ -12,12 +12,7 @@ from dbt.adapters.factory import Adapter
 from dbt.main import handle_and_check
 from dbt.logger import log_manager
 from dbt.contracts.graph.manifest import Manifest
-from dbt.events.functions import (
-    fire_event,
-    capture_stdout_logs,
-    stop_capture_stdout_logs,
-    reset_metadata_vars,
-)
+from dbt.events.functions import fire_event, capture_stdout_logs, stop_capture_stdout_logs, reset_metadata_vars
 from dbt.events.test_types import IntegrationTestDebug

 # =============================================================================
--- a/core/dbt/version.py
+++ b/core/dbt/version.py
@@ -235,5 +235,5 @@ def _get_adapter_plugin_names() -> Iterator[str]:
            yield plugin_name


-__version__ = "1.5.0a1"
+__version__ = "1.4.0"
 installed = get_installed_version()
--- a/core/setup.py
+++ b/core/setup.py
@@ -25,7 +25,7 @@ with open(os.path.join(this_directory, "README.md")) as f:


 package_name = "dbt-core"
-package_version = "1.5.0a1"
+package_version = "1.4.0"
 description = """With dbt, data analysts and engineers can build analytics \
 the way engineers build applications."""

--- a/docker/Dockerfile
+++ b/docker/Dockerfile
@@ -14,12 +14,12 @@ FROM --platform=$build_for python:3.10.7-slim-bullseye as base
 # N.B. The refs updated automagically every release via bumpversion
 # N.B. dbt-postgres is currently found in the core codebase so a value of dbt-core@<some_version> is correct

-ARG dbt_core_ref=dbt-core@v1.5.0a1
-ARG dbt_postgres_ref=dbt-core@v1.5.0a1
-ARG dbt_redshift_ref=dbt-redshift@v1.5.0a1
-ARG dbt_bigquery_ref=dbt-bigquery@v1.5.0a1
-ARG dbt_snowflake_ref=dbt-snowflake@v1.5.0a1
-ARG dbt_spark_ref=dbt-spark@v1.5.0a1
+ARG dbt_core_ref=dbt-core@v1.4.0
+ARG dbt_postgres_ref=dbt-core@v1.4.0
+ARG dbt_redshift_ref=dbt-redshift@v1.4.0
+ARG dbt_bigquery_ref=dbt-bigquery@v1.4.0
+ARG dbt_snowflake_ref=dbt-snowflake@v1.4.0
+ARG dbt_spark_ref=dbt-spark@v1.4.0
 # special case args
 ARG dbt_spark_version=all
 ARG dbt_third_party
--- a/plugins/postgres/dbt/adapters/postgres/version.py
+++ b/plugins/postgres/dbt/adapters/postgres/version.py
@@ -1 +1 @@
-version = "1.5.0a1"
+version = "1.4.0"
--- a/plugins/postgres/setup.py
+++ b/plugins/postgres/setup.py
@@ -41,7 +41,7 @@ def _dbt_psycopg2_name():


 package_name = "dbt-postgres"
-package_version = "1.5.0a1"
+package_version = "1.4.0"
 description = """The postgres adapter plugin for dbt (data build tool)"""

 this_directory = os.path.abspath(os.path.dirname(__file__))
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -6,6 +6,6 @@ namespace_packages = true

 [tool.black]
 # TODO: remove global exclusion of tests when testing overhaul is complete
-force-exclude = 'test/'
+force-exclude = 'test'
 line-length = 99
 target-version = ['py38']
--- a/schemas/dbt/catalog/v1.json
+++ b/schemas/dbt/catalog/v1.json
@@ -36,7 +36,7 @@
    }
  },
  "additionalProperties": false,
-  "description": "CatalogArtifact(metadata: dbt.contracts.results.CatalogMetadata, nodes: Dict[str, dbt.contracts.results.CatalogTable], sources: Dict[str, dbt.contracts.results.CatalogTable], errors: Optional[List[str]] = None, _compile_results: Optional[Any] = None)",
+  "description": "CatalogArtifact(metadata: dbt.contracts.results.CatalogMetadata, nodes: Dict[str, dbt.contracts.results.CatalogTable], sources: Dict[str, dbt.contracts.results.CatalogTable], errors: Union[List[str], NoneType] = None, _compile_results: Union[Any, NoneType] = None)",
  "definitions": {
    "CatalogMetadata": {
      "type": "object",
@@ -48,12 +48,12 @@
        },
        "dbt_version": {
          "type": "string",
-          "default": "1.5.0a1"
+          "default": "1.2.0a1"
        },
        "generated_at": {
          "type": "string",
          "format": "date-time",
-          "default": "2023-01-23T21:56:17.789289Z"
+          "default": "2022-04-15T20:38:22.701177Z"
        },
        "invocation_id": {
          "oneOf": [
@@ -64,7 +64,7 @@
              "type": "null"
            }
          ],
-          "default": "10c9c26b-6682-4d46-84d2-12f641a070e5"
+          "default": "34abf75e-59d3-442f-920c-fa3843d98014"
        },
        "env": {
          "type": "object",
@@ -75,7 +75,7 @@
        }
      },
      "additionalProperties": false,
-      "description": "CatalogMetadata(dbt_schema_version: str = <factory>, dbt_version: str = '1.5.0a1', generated_at: datetime.datetime = <factory>, invocation_id: Optional[str] = <factory>, env: Dict[str, str] = <factory>)"
+      "description": "CatalogMetadata(dbt_schema_version: str = <factory>, dbt_version: str = '1.2.0a1', generated_at: datetime.datetime = <factory>, invocation_id: Union[str, NoneType] = <factory>, env: Dict[str, str] = <factory>)"
    },
    "CatalogTable": {
      "type": "object",
@@ -112,7 +112,7 @@
        }
      },
      "additionalProperties": false,
-      "description": "CatalogTable(metadata: dbt.contracts.results.TableMetadata, columns: Dict[str, dbt.contracts.results.ColumnMetadata], stats: Dict[str, dbt.contracts.results.StatsItem], unique_id: Optional[str] = None)"
+      "description": "CatalogTable(metadata: dbt.contracts.results.TableMetadata, columns: Dict[str, dbt.contracts.results.ColumnMetadata], stats: Dict[str, dbt.contracts.results.StatsItem], unique_id: Union[str, NoneType] = None)"
    },
    "TableMetadata": {
      "type": "object",
@@ -163,7 +163,7 @@
        }
      },
      "additionalProperties": false,
-      "description": "TableMetadata(type: str, schema: str, name: str, database: Optional[str] = None, comment: Optional[str] = None, owner: Optional[str] = None)"
+      "description": "TableMetadata(type: str, schema: str, name: str, database: Union[str, NoneType] = None, comment: Union[str, NoneType] = None, owner: Union[str, NoneType] = None)"
    },
    "ColumnMetadata": {
      "type": "object",
@@ -194,7 +194,7 @@
        }
      },
      "additionalProperties": false,
-      "description": "ColumnMetadata(type: str, index: int, name: str, comment: Optional[str] = None)"
+      "description": "ColumnMetadata(type: str, index: int, name: str, comment: Union[str, NoneType] = None)"
    },
    "StatsItem": {
      "type": "object",
@@ -241,7 +241,7 @@
        }
      },
      "additionalProperties": false,
-      "description": "StatsItem(id: str, label: str, value: Union[bool, str, float, NoneType], include: bool, description: Optional[str] = None)"
+      "description": "StatsItem(id: str, label: str, value: Union[bool, str, float, NoneType], include: bool, description: Union[str, NoneType] = None)"
    }
  },
  "$schema": "http://json-schema.org/draft-07/schema#",
--- a/schemas/dbt/manifest/v5.json
+++ b/schemas/dbt/manifest/v5.json
--- a/schemas/dbt/manifest/v6.json
+++ b/schemas/dbt/manifest/v6.json
--- a/schemas/dbt/manifest/v7.json
+++ b/schemas/dbt/manifest/v7.json
--- a/schemas/dbt/manifest/v8.json
+++ b/schemas/dbt/manifest/v8.json
@@ -8,7 +8,6 @@
    "docs",
    "exposures",
    "metrics",
-    "entities",
    "selectors"
  ],
  "properties": {
@@ -86,13 +85,6 @@
      },
      "description": "The metrics defined in the dbt project and its dependencies"
    },
-    "entities": {
-      "type": "object",
-      "additionalProperties": {
-        "$ref": "#/definitions/Entity"
-      },
-      "description": "The entities defined in the dbt project and its dependencies"
-    },
    "selectors": {
      "type": "object",
      "description": "The selectors defined in selectors.yml"
@@ -181,7 +173,7 @@
    }
  },
  "additionalProperties": false,
-  "description": "WritableManifest(metadata: dbt.contracts.graph.manifest.ManifestMetadata, nodes: Mapping[str, Union[dbt.contracts.graph.nodes.AnalysisNode, dbt.contracts.graph.nodes.SingularTestNode, dbt.contracts.graph.nodes.HookNode, dbt.contracts.graph.nodes.ModelNode, dbt.contracts.graph.nodes.RPCNode, dbt.contracts.graph.nodes.SqlNode, dbt.contracts.graph.nodes.GenericTestNode, dbt.contracts.graph.nodes.SnapshotNode, dbt.contracts.graph.nodes.SeedNode]], sources: Mapping[str, dbt.contracts.graph.nodes.SourceDefinition], macros: Mapping[str, dbt.contracts.graph.nodes.Macro], docs: Mapping[str, dbt.contracts.graph.nodes.Documentation], exposures: Mapping[str, dbt.contracts.graph.nodes.Exposure], metrics: Mapping[str, dbt.contracts.graph.nodes.Metric], entities: Mapping[str, dbt.contracts.graph.nodes.Entity], selectors: Mapping[str, Any], disabled: Optional[Mapping[str, List[Union[dbt.contracts.graph.nodes.AnalysisNode, dbt.contracts.graph.nodes.SingularTestNode, dbt.contracts.graph.nodes.HookNode, dbt.contracts.graph.nodes.ModelNode, dbt.contracts.graph.nodes.RPCNode, dbt.contracts.graph.nodes.SqlNode, dbt.contracts.graph.nodes.GenericTestNode, dbt.contracts.graph.nodes.SnapshotNode, dbt.contracts.graph.nodes.SeedNode, dbt.contracts.graph.nodes.SourceDefinition]]]], parent_map: Optional[Dict[str, List[str]]], child_map: Optional[Dict[str, List[str]]])",
+  "description": "WritableManifest(metadata: dbt.contracts.graph.manifest.ManifestMetadata, nodes: Mapping[str, Union[dbt.contracts.graph.nodes.AnalysisNode, dbt.contracts.graph.nodes.SingularTestNode, dbt.contracts.graph.nodes.HookNode, dbt.contracts.graph.nodes.ModelNode, dbt.contracts.graph.nodes.RPCNode, dbt.contracts.graph.nodes.SqlNode, dbt.contracts.graph.nodes.GenericTestNode, dbt.contracts.graph.nodes.SnapshotNode, dbt.contracts.graph.nodes.SeedNode]], sources: Mapping[str, dbt.contracts.graph.nodes.SourceDefinition], macros: Mapping[str, dbt.contracts.graph.nodes.Macro], docs: Mapping[str, dbt.contracts.graph.nodes.Documentation], exposures: Mapping[str, dbt.contracts.graph.nodes.Exposure], metrics: Mapping[str, dbt.contracts.graph.nodes.Metric], selectors: Mapping[str, Any], disabled: Optional[Mapping[str, List[Union[dbt.contracts.graph.nodes.AnalysisNode, dbt.contracts.graph.nodes.SingularTestNode, dbt.contracts.graph.nodes.HookNode, dbt.contracts.graph.nodes.ModelNode, dbt.contracts.graph.nodes.RPCNode, dbt.contracts.graph.nodes.SqlNode, dbt.contracts.graph.nodes.GenericTestNode, dbt.contracts.graph.nodes.SnapshotNode, dbt.contracts.graph.nodes.SeedNode, dbt.contracts.graph.nodes.SourceDefinition]]]], parent_map: Optional[Dict[str, List[str]]], child_map: Optional[Dict[str, List[str]]])",
  "definitions": {
    "ManifestMetadata": {
      "type": "object",
@@ -193,12 +185,12 @@
        },
        "dbt_version": {
          "type": "string",
-          "default": "1.5.0a1"
+          "default": "1.4.0a1"
        },
        "generated_at": {
          "type": "string",
          "format": "date-time",
-          "default": "2023-01-23T21:56:17.790304Z"
+          "default": "2022-12-13T03:30:15.966964Z"
        },
        "invocation_id": {
          "oneOf": [
@@ -209,7 +201,7 @@
              "type": "null"
            }
          ],
-          "default": "10c9c26b-6682-4d46-84d2-12f641a070e5"
+          "default": "4f2b967b-7e02-46de-a7ea-268a05e3fab1"
        },
        "env": {
          "type": "object",
@@ -270,6 +262,7 @@
    "AnalysisNode": {
      "type": "object",
      "required": [
+        "database",
        "schema",
        "name",
        "resource_type",
@@ -283,14 +276,7 @@
      ],
      "properties": {
        "database": {
-          "oneOf": [
-            {
-              "type": "string"
-            },
-            {
-              "type": "null"
-            }
-          ]
+          "type": "string"
        },
        "schema": {
          "type": "string"
@@ -414,7 +400,7 @@
        },
        "created_at": {
          "type": "number",
-          "default": 1674510977.792257
+          "default": 1670902215.970579
        },
        "config_call_dict": {
          "type": "object",
@@ -468,16 +454,6 @@
          },
          "default": []
        },
-        "entities": {
-          "type": "array",
-          "items": {
-            "type": "array",
-            "items": {
-              "type": "string"
-            }
-          },
-          "default": []
-        },
        "depends_on": {
          "$ref": "#/definitions/DependsOn",
          "default": {
@@ -522,7 +498,7 @@
        }
      },
      "additionalProperties": false,
-      "description": "AnalysisNode(database: Optional[str], schema: str, name: str, resource_type: dbt.node_types.NodeType, package_name: str, path: str, original_file_path: str, unique_id: str, fqn: List[str], alias: str, checksum: dbt.contracts.files.FileHash, config: dbt.contracts.graph.model_config.NodeConfig = <factory>, _event_status: Dict[str, Any] = <factory>, tags: List[str] = <factory>, description: str = '', columns: Dict[str, dbt.contracts.graph.nodes.ColumnInfo] = <factory>, meta: Dict[str, Any] = <factory>, docs: dbt.contracts.graph.unparsed.Docs = <factory>, patch_path: Optional[str] = None, build_path: Optional[str] = None, deferred: bool = False, unrendered_config: Dict[str, Any] = <factory>, created_at: float = <factory>, config_call_dict: Dict[str, Any] = <factory>, relation_name: Optional[str] = None, raw_code: str = '', language: str = 'sql', refs: List[List[str]] = <factory>, sources: List[List[str]] = <factory>, metrics: List[List[str]] = <factory>, entities: List[List[str]] = <factory>, depends_on: dbt.contracts.graph.nodes.DependsOn = <factory>, compiled_path: Optional[str] = None, compiled: bool = False, compiled_code: Optional[str] = None, extra_ctes_injected: bool = False, extra_ctes: List[dbt.contracts.graph.nodes.InjectedCTE] = <factory>, _pre_injected_sql: Optional[str] = None)"
+      "description": "AnalysisNode(database: str, schema: str, name: str, resource_type: dbt.node_types.NodeType, package_name: str, path: str, original_file_path: str, unique_id: str, fqn: List[str], alias: str, checksum: dbt.contracts.files.FileHash, config: dbt.contracts.graph.model_config.NodeConfig = <factory>, _event_status: Dict[str, Any] = <factory>, tags: List[str] = <factory>, description: str = '', columns: Dict[str, dbt.contracts.graph.nodes.ColumnInfo] = <factory>, meta: Dict[str, Any] = <factory>, docs: dbt.contracts.graph.unparsed.Docs = <factory>, patch_path: Optional[str] = None, build_path: Optional[str] = None, deferred: bool = False, unrendered_config: Dict[str, Any] = <factory>, created_at: float = <factory>, config_call_dict: Dict[str, Any] = <factory>, relation_name: Optional[str] = None, raw_code: str = '', language: str = 'sql', refs: List[List[str]] = <factory>, sources: List[List[str]] = <factory>, metrics: List[List[str]] = <factory>, depends_on: dbt.contracts.graph.nodes.DependsOn = <factory>, compiled_path: Optional[str] = None, compiled: bool = False, compiled_code: Optional[str] = None, extra_ctes_injected: bool = False, extra_ctes: List[dbt.contracts.graph.nodes.InjectedCTE] = <factory>, _pre_injected_sql: Optional[str] = None)"
    },
    "FileHash": {
      "type": "object",
@@ -835,6 +811,7 @@
    "SingularTestNode": {
      "type": "object",
      "required": [
+        "database",
        "schema",
        "name",
        "resource_type",
@@ -848,14 +825,7 @@
      ],
      "properties": {
        "database": {
-          "oneOf": [
-            {
-              "type": "string"
-            },
-            {
-              "type": "null"
-            }
-          ]
+          "type": "string"
        },
        "schema": {
          "type": "string"
@@ -971,7 +941,7 @@
        },
        "created_at": {
          "type": "number",
-          "default": 1674510977.79368
+          "default": 1670902215.973521
        },
        "config_call_dict": {
          "type": "object",
@@ -1025,16 +995,6 @@
          },
          "default": []
        },
-        "entities": {
-          "type": "array",
-          "items": {
-            "type": "array",
-            "items": {
-              "type": "string"
-            }
-          },
-          "default": []
-        },
        "depends_on": {
          "$ref": "#/definitions/DependsOn",
          "default": {
@@ -1079,7 +1039,7 @@
        }
      },
      "additionalProperties": false,
-      "description": "SingularTestNode(database: Optional[str], schema: str, name: str, resource_type: dbt.node_types.NodeType, package_name: str, path: str, original_file_path: str, unique_id: str, fqn: List[str], alias: str, checksum: dbt.contracts.files.FileHash, config: dbt.contracts.graph.model_config.TestConfig = <factory>, _event_status: Dict[str, Any] = <factory>, tags: List[str] = <factory>, description: str = '', columns: Dict[str, dbt.contracts.graph.nodes.ColumnInfo] = <factory>, meta: Dict[str, Any] = <factory>, docs: dbt.contracts.graph.unparsed.Docs = <factory>, patch_path: Optional[str] = None, build_path: Optional[str] = None, deferred: bool = False, unrendered_config: Dict[str, Any] = <factory>, created_at: float = <factory>, config_call_dict: Dict[str, Any] = <factory>, relation_name: Optional[str] = None, raw_code: str = '', language: str = 'sql', refs: List[List[str]] = <factory>, sources: List[List[str]] = <factory>, metrics: List[List[str]] = <factory>, entities: List[List[str]] = <factory>, depends_on: dbt.contracts.graph.nodes.DependsOn = <factory>, compiled_path: Optional[str] = None, compiled: bool = False, compiled_code: Optional[str] = None, extra_ctes_injected: bool = False, extra_ctes: List[dbt.contracts.graph.nodes.InjectedCTE] = <factory>, _pre_injected_sql: Optional[str] = None)"
+      "description": "SingularTestNode(database: str, schema: str, name: str, resource_type: dbt.node_types.NodeType, package_name: str, path: str, original_file_path: str, unique_id: str, fqn: List[str], alias: str, checksum: dbt.contracts.files.FileHash, config: dbt.contracts.graph.model_config.TestConfig = <factory>, _event_status: Dict[str, Any] = <factory>, tags: List[str] = <factory>, description: str = '', columns: Dict[str, dbt.contracts.graph.nodes.ColumnInfo] = <factory>, meta: Dict[str, Any] = <factory>, docs: dbt.contracts.graph.unparsed.Docs = <factory>, patch_path: Optional[str] = None, build_path: Optional[str] = None, deferred: bool = False, unrendered_config: Dict[str, Any] = <factory>, created_at: float = <factory>, config_call_dict: Dict[str, Any] = <factory>, relation_name: Optional[str] = None, raw_code: str = '', language: str = 'sql', refs: List[List[str]] = <factory>, sources: List[List[str]] = <factory>, metrics: List[List[str]] = <factory>, depends_on: dbt.contracts.graph.nodes.DependsOn = <factory>, compiled_path: Optional[str] = None, compiled: bool = False, compiled_code: Optional[str] = None, extra_ctes_injected: bool = False, extra_ctes: List[dbt.contracts.graph.nodes.InjectedCTE] = <factory>, _pre_injected_sql: Optional[str] = None)"
    },
    "TestConfig": {
      "type": "object",
@@ -1196,6 +1156,7 @@
    "HookNode": {
      "type": "object",
      "required": [
+        "database",
        "schema",
        "name",
        "resource_type",
@@ -1209,14 +1170,7 @@
      ],
      "properties": {
        "database": {
-          "oneOf": [
-            {
-              "type": "string"
-            },
-            {
-              "type": "null"
-            }
-          ]
+          "type": "string"
        },
        "schema": {
          "type": "string"
@@ -1340,7 +1294,7 @@
        },
        "created_at": {
          "type": "number",
-          "default": 1674510977.795094
+          "default": 1670902215.975156
        },
        "config_call_dict": {
          "type": "object",
@@ -1394,16 +1348,6 @@
          },
          "default": []
        },
-        "entities": {
-          "type": "array",
-          "items": {
-            "type": "array",
-            "items": {
-              "type": "string"
-            }
-          },
-          "default": []
-        },
        "depends_on": {
          "$ref": "#/definitions/DependsOn",
          "default": {
@@ -1458,11 +1402,12 @@
        }
      },
      "additionalProperties": false,
-      "description": "HookNode(database: Optional[str], schema: str, name: str, resource_type: dbt.node_types.NodeType, package_name: str, path: str, original_file_path: str, unique_id: str, fqn: List[str], alias: str, checksum: dbt.contracts.files.FileHash, config: dbt.contracts.graph.model_config.NodeConfig = <factory>, _event_status: Dict[str, Any] = <factory>, tags: List[str] = <factory>, description: str = '', columns: Dict[str, dbt.contracts.graph.nodes.ColumnInfo] = <factory>, meta: Dict[str, Any] = <factory>, docs: dbt.contracts.graph.unparsed.Docs = <factory>, patch_path: Optional[str] = None, build_path: Optional[str] = None, deferred: bool = False, unrendered_config: Dict[str, Any] = <factory>, created_at: float = <factory>, config_call_dict: Dict[str, Any] = <factory>, relation_name: Optional[str] = None, raw_code: str = '', language: str = 'sql', refs: List[List[str]] = <factory>, sources: List[List[str]] = <factory>, metrics: List[List[str]] = <factory>, entities: List[List[str]] = <factory>, depends_on: dbt.contracts.graph.nodes.DependsOn = <factory>, compiled_path: Optional[str] = None, compiled: bool = False, compiled_code: Optional[str] = None, extra_ctes_injected: bool = False, extra_ctes: List[dbt.contracts.graph.nodes.InjectedCTE] = <factory>, _pre_injected_sql: Optional[str] = None, index: Optional[int] = None)"
+      "description": "HookNode(database: str, schema: str, name: str, resource_type: dbt.node_types.NodeType, package_name: str, path: str, original_file_path: str, unique_id: str, fqn: List[str], alias: str, checksum: dbt.contracts.files.FileHash, config: dbt.contracts.graph.model_config.NodeConfig = <factory>, _event_status: Dict[str, Any] = <factory>, tags: List[str] = <factory>, description: str = '', columns: Dict[str, dbt.contracts.graph.nodes.ColumnInfo] = <factory>, meta: Dict[str, Any] = <factory>, docs: dbt.contracts.graph.unparsed.Docs = <factory>, patch_path: Optional[str] = None, build_path: Optional[str] = None, deferred: bool = False, unrendered_config: Dict[str, Any] = <factory>, created_at: float = <factory>, config_call_dict: Dict[str, Any] = <factory>, relation_name: Optional[str] = None, raw_code: str = '', language: str = 'sql', refs: List[List[str]] = <factory>, sources: List[List[str]] = <factory>, metrics: List[List[str]] = <factory>, depends_on: dbt.contracts.graph.nodes.DependsOn = <factory>, compiled_path: Optional[str] = None, compiled: bool = False, compiled_code: Optional[str] = None, extra_ctes_injected: bool = False, extra_ctes: List[dbt.contracts.graph.nodes.InjectedCTE] = <factory>, _pre_injected_sql: Optional[str] = None, index: Optional[int] = None)"
    },
    "ModelNode": {
      "type": "object",
      "required": [
+        "database",
        "schema",
        "name",
        "resource_type",
@@ -1476,14 +1421,7 @@
      ],
      "properties": {
        "database": {
-          "oneOf": [
-            {
-              "type": "string"
-            },
-            {
-              "type": "null"
-            }
-          ]
+          "type": "string"
        },
        "schema": {
          "type": "string"
@@ -1607,7 +1545,7 @@
        },
        "created_at": {
          "type": "number",
-          "default": 1674510977.7959611
+          "default": 1670902215.976732
        },
        "config_call_dict": {
          "type": "object",
@@ -1661,16 +1599,6 @@
          },
          "default": []
        },
-        "entities": {
-          "type": "array",
-          "items": {
-            "type": "array",
-            "items": {
-              "type": "string"
-            }
-          },
-          "default": []
-        },
        "depends_on": {
          "$ref": "#/definitions/DependsOn",
          "default": {
@@ -1715,11 +1643,12 @@
        }
      },
      "additionalProperties": false,
-      "description": "ModelNode(database: Optional[str], schema: str, name: str, resource_type: dbt.node_types.NodeType, package_name: str, path: str, original_file_path: str, unique_id: str, fqn: List[str], alias: str, checksum: dbt.contracts.files.FileHash, config: dbt.contracts.graph.model_config.NodeConfig = <factory>, _event_status: Dict[str, Any] = <factory>, tags: List[str] = <factory>, description: str = '', columns: Dict[str, dbt.contracts.graph.nodes.ColumnInfo] = <factory>, meta: Dict[str, Any] = <factory>, docs: dbt.contracts.graph.unparsed.Docs = <factory>, patch_path: Optional[str] = None, build_path: Optional[str] = None, deferred: bool = False, unrendered_config: Dict[str, Any] = <factory>, created_at: float = <factory>, config_call_dict: Dict[str, Any] = <factory>, relation_name: Optional[str] = None, raw_code: str = '', language: str = 'sql', refs: List[List[str]] = <factory>, sources: List[List[str]] = <factory>, metrics: List[List[str]] = <factory>, entities: List[List[str]] = <factory>, depends_on: dbt.contracts.graph.nodes.DependsOn = <factory>, compiled_path: Optional[str] = None, compiled: bool = False, compiled_code: Optional[str] = None, extra_ctes_injected: bool = False, extra_ctes: List[dbt.contracts.graph.nodes.InjectedCTE] = <factory>, _pre_injected_sql: Optional[str] = None)"
+      "description": "ModelNode(database: str, schema: str, name: str, resource_type: dbt.node_types.NodeType, package_name: str, path: str, original_file_path: str, unique_id: str, fqn: List[str], alias: str, checksum: dbt.contracts.files.FileHash, config: dbt.contracts.graph.model_config.NodeConfig = <factory>, _event_status: Dict[str, Any] = <factory>, tags: List[str] = <factory>, description: str = '', columns: Dict[str, dbt.contracts.graph.nodes.ColumnInfo] = <factory>, meta: Dict[str, Any] = <factory>, docs: dbt.contracts.graph.unparsed.Docs = <factory>, patch_path: Optional[str] = None, build_path: Optional[str] = None, deferred: bool = False, unrendered_config: Dict[str, Any] = <factory>, created_at: float = <factory>, config_call_dict: Dict[str, Any] = <factory>, relation_name: Optional[str] = None, raw_code: str = '', language: str = 'sql', refs: List[List[str]] = <factory>, sources: List[List[str]] = <factory>, metrics: List[List[str]] = <factory>, depends_on: dbt.contracts.graph.nodes.DependsOn = <factory>, compiled_path: Optional[str] = None, compiled: bool = False, compiled_code: Optional[str] = None, extra_ctes_injected: bool = False, extra_ctes: List[dbt.contracts.graph.nodes.InjectedCTE] = <factory>, _pre_injected_sql: Optional[str] = None)"
    },
    "RPCNode": {
      "type": "object",
      "required": [
+        "database",
        "schema",
        "name",
        "resource_type",
@@ -1733,14 +1662,7 @@
      ],
      "properties": {
        "database": {
-          "oneOf": [
-            {
-              "type": "string"
-            },
-            {
-              "type": "null"
-            }
-          ]
+          "type": "string"
        },
        "schema": {
          "type": "string"
@@ -1864,7 +1786,7 @@
        },
        "created_at": {
          "type": "number",
-          "default": 1674510977.796774
+          "default": 1670902215.978195
        },
        "config_call_dict": {
          "type": "object",
@@ -1918,16 +1840,6 @@
          },
          "default": []
        },
-        "entities": {
-          "type": "array",
-          "items": {
-            "type": "array",
-            "items": {
-              "type": "string"
-            }
-          },
-          "default": []
-        },
        "depends_on": {
          "$ref": "#/definitions/DependsOn",
          "default": {
@@ -1972,11 +1884,12 @@
        }
      },
      "additionalProperties": false,
-      "description": "RPCNode(database: Optional[str], schema: str, name: str, resource_type: dbt.node_types.NodeType, package_name: str, path: str, original_file_path: str, unique_id: str, fqn: List[str], alias: str, checksum: dbt.contracts.files.FileHash, config: dbt.contracts.graph.model_config.NodeConfig = <factory>, _event_status: Dict[str, Any] = <factory>, tags: List[str] = <factory>, description: str = '', columns: Dict[str, dbt.contracts.graph.nodes.ColumnInfo] = <factory>, meta: Dict[str, Any] = <factory>, docs: dbt.contracts.graph.unparsed.Docs = <factory>, patch_path: Optional[str] = None, build_path: Optional[str] = None, deferred: bool = False, unrendered_config: Dict[str, Any] = <factory>, created_at: float = <factory>, config_call_dict: Dict[str, Any] = <factory>, relation_name: Optional[str] = None, raw_code: str = '', language: str = 'sql', refs: List[List[str]] = <factory>, sources: List[List[str]] = <factory>, metrics: List[List[str]] = <factory>, entities: List[List[str]] = <factory>, depends_on: dbt.contracts.graph.nodes.DependsOn = <factory>, compiled_path: Optional[str] = None, compiled: bool = False, compiled_code: Optional[str] = None, extra_ctes_injected: bool = False, extra_ctes: List[dbt.contracts.graph.nodes.InjectedCTE] = <factory>, _pre_injected_sql: Optional[str] = None)"
+      "description": "RPCNode(database: str, schema: str, name: str, resource_type: dbt.node_types.NodeType, package_name: str, path: str, original_file_path: str, unique_id: str, fqn: List[str], alias: str, checksum: dbt.contracts.files.FileHash, config: dbt.contracts.graph.model_config.NodeConfig = <factory>, _event_status: Dict[str, Any] = <factory>, tags: List[str] = <factory>, description: str = '', columns: Dict[str, dbt.contracts.graph.nodes.ColumnInfo] = <factory>, meta: Dict[str, Any] = <factory>, docs: dbt.contracts.graph.unparsed.Docs = <factory>, patch_path: Optional[str] = None, build_path: Optional[str] = None, deferred: bool = False, unrendered_config: Dict[str, Any] = <factory>, created_at: float = <factory>, config_call_dict: Dict[str, Any] = <factory>, relation_name: Optional[str] = None, raw_code: str = '', language: str = 'sql', refs: List[List[str]] = <factory>, sources: List[List[str]] = <factory>, metrics: List[List[str]] = <factory>, depends_on: dbt.contracts.graph.nodes.DependsOn = <factory>, compiled_path: Optional[str] = None, compiled: bool = False, compiled_code: Optional[str] = None, extra_ctes_injected: bool = False, extra_ctes: List[dbt.contracts.graph.nodes.InjectedCTE] = <factory>, _pre_injected_sql: Optional[str] = None)"
    },
    "SqlNode": {
      "type": "object",
      "required": [
+        "database",
        "schema",
        "name",
        "resource_type",
@@ -1990,14 +1903,7 @@
      ],
      "properties": {
        "database": {
-          "oneOf": [
-            {
-              "type": "string"
-            },
-            {
-              "type": "null"
-            }
-          ]
+          "type": "string"
        },
        "schema": {
          "type": "string"
@@ -2121,7 +2027,7 @@
        },
        "created_at": {
          "type": "number",
-          "default": 1674510977.797567
+          "default": 1670902215.979718
        },
        "config_call_dict": {
          "type": "object",
@@ -2175,16 +2081,6 @@
          },
          "default": []
        },
-        "entities": {
-          "type": "array",
-          "items": {
-            "type": "array",
-            "items": {
-              "type": "string"
-            }
-          },
-          "default": []
-        },
        "depends_on": {
          "$ref": "#/definitions/DependsOn",
          "default": {
@@ -2229,12 +2125,13 @@
        }
      },
      "additionalProperties": false,
-      "description": "SqlNode(database: Optional[str], schema: str, name: str, resource_type: dbt.node_types.NodeType, package_name: str, path: str, original_file_path: str, unique_id: str, fqn: List[str], alias: str, checksum: dbt.contracts.files.FileHash, config: dbt.contracts.graph.model_config.NodeConfig = <factory>, _event_status: Dict[str, Any] = <factory>, tags: List[str] = <factory>, description: str = '', columns: Dict[str, dbt.contracts.graph.nodes.ColumnInfo] = <factory>, meta: Dict[str, Any] = <factory>, docs: dbt.contracts.graph.unparsed.Docs = <factory>, patch_path: Optional[str] = None, build_path: Optional[str] = None, deferred: bool = False, unrendered_config: Dict[str, Any] = <factory>, created_at: float = <factory>, config_call_dict: Dict[str, Any] = <factory>, relation_name: Optional[str] = None, raw_code: str = '', language: str = 'sql', refs: List[List[str]] = <factory>, sources: List[List[str]] = <factory>, metrics: List[List[str]] = <factory>, entities: List[List[str]] = <factory>, depends_on: dbt.contracts.graph.nodes.DependsOn = <factory>, compiled_path: Optional[str] = None, compiled: bool = False, compiled_code: Optional[str] = None, extra_ctes_injected: bool = False, extra_ctes: List[dbt.contracts.graph.nodes.InjectedCTE] = <factory>, _pre_injected_sql: Optional[str] = None)"
+      "description": "SqlNode(database: str, schema: str, name: str, resource_type: dbt.node_types.NodeType, package_name: str, path: str, original_file_path: str, unique_id: str, fqn: List[str], alias: str, checksum: dbt.contracts.files.FileHash, config: dbt.contracts.graph.model_config.NodeConfig = <factory>, _event_status: Dict[str, Any] = <factory>, tags: List[str] = <factory>, description: str = '', columns: Dict[str, dbt.contracts.graph.nodes.ColumnInfo] = <factory>, meta: Dict[str, Any] = <factory>, docs: dbt.contracts.graph.unparsed.Docs = <factory>, patch_path: Optional[str] = None, build_path: Optional[str] = None, deferred: bool = False, unrendered_config: Dict[str, Any] = <factory>, created_at: float = <factory>, config_call_dict: Dict[str, Any] = <factory>, relation_name: Optional[str] = None, raw_code: str = '', language: str = 'sql', refs: List[List[str]] = <factory>, sources: List[List[str]] = <factory>, metrics: List[List[str]] = <factory>, depends_on: dbt.contracts.graph.nodes.DependsOn = <factory>, compiled_path: Optional[str] = None, compiled: bool = False, compiled_code: Optional[str] = None, extra_ctes_injected: bool = False, extra_ctes: List[dbt.contracts.graph.nodes.InjectedCTE] = <factory>, _pre_injected_sql: Optional[str] = None)"
    },
    "GenericTestNode": {
      "type": "object",
      "required": [
        "test_metadata",
+        "database",
        "schema",
        "name",
        "resource_type",
@@ -2251,14 +2148,7 @@
          "$ref": "#/definitions/TestMetadata"
        },
        "database": {
-          "oneOf": [
-            {
-              "type": "string"
-            },
-            {
-              "type": "null"
-            }
-          ]
+          "type": "string"
        },
        "schema": {
          "type": "string"
@@ -2374,7 +2264,7 @@
        },
        "created_at": {
          "type": "number",
-          "default": 1674510977.79852
+          "default": 1670902215.981434
        },
        "config_call_dict": {
          "type": "object",
@@ -2428,16 +2318,6 @@
          },
          "default": []
        },
-        "entities": {
-          "type": "array",
-          "items": {
-            "type": "array",
-            "items": {
-              "type": "string"
-            }
-          },
-          "default": []
-        },
        "depends_on": {
          "$ref": "#/definitions/DependsOn",
          "default": {
@@ -2502,7 +2382,7 @@
        }
      },
      "additionalProperties": false,
-      "description": "GenericTestNode(test_metadata: dbt.contracts.graph.nodes.TestMetadata, database: Optional[str], schema: str, name: str, resource_type: dbt.node_types.NodeType, package_name: str, path: str, original_file_path: str, unique_id: str, fqn: List[str], alias: str, checksum: dbt.contracts.files.FileHash, config: dbt.contracts.graph.model_config.TestConfig = <factory>, _event_status: Dict[str, Any] = <factory>, tags: List[str] = <factory>, description: str = '', columns: Dict[str, dbt.contracts.graph.nodes.ColumnInfo] = <factory>, meta: Dict[str, Any] = <factory>, docs: dbt.contracts.graph.unparsed.Docs = <factory>, patch_path: Optional[str] = None, build_path: Optional[str] = None, deferred: bool = False, unrendered_config: Dict[str, Any] = <factory>, created_at: float = <factory>, config_call_dict: Dict[str, Any] = <factory>, relation_name: Optional[str] = None, raw_code: str = '', language: str = 'sql', refs: List[List[str]] = <factory>, sources: List[List[str]] = <factory>, metrics: List[List[str]] = <factory>, entities: List[List[str]] = <factory>, depends_on: dbt.contracts.graph.nodes.DependsOn = <factory>, compiled_path: Optional[str] = None, compiled: bool = False, compiled_code: Optional[str] = None, extra_ctes_injected: bool = False, extra_ctes: List[dbt.contracts.graph.nodes.InjectedCTE] = <factory>, _pre_injected_sql: Optional[str] = None, column_name: Optional[str] = None, file_key_name: Optional[str] = None)"
+      "description": "GenericTestNode(test_metadata: dbt.contracts.graph.nodes.TestMetadata, database: str, schema: str, name: str, resource_type: dbt.node_types.NodeType, package_name: str, path: str, original_file_path: str, unique_id: str, fqn: List[str], alias: str, checksum: dbt.contracts.files.FileHash, config: dbt.contracts.graph.model_config.TestConfig = <factory>, _event_status: Dict[str, Any] = <factory>, tags: List[str] = <factory>, description: str = '', columns: Dict[str, dbt.contracts.graph.nodes.ColumnInfo] = <factory>, meta: Dict[str, Any] = <factory>, docs: dbt.contracts.graph.unparsed.Docs = <factory>, patch_path: Optional[str] = None, build_path: Optional[str] = None, deferred: bool = False, unrendered_config: Dict[str, Any] = <factory>, created_at: float = <factory>, config_call_dict: Dict[str, Any] = <factory>, relation_name: Optional[str] = None, raw_code: str = '', language: str = 'sql', refs: List[List[str]] = <factory>, sources: List[List[str]] = <factory>, metrics: List[List[str]] = <factory>, depends_on: dbt.contracts.graph.nodes.DependsOn = <factory>, compiled_path: Optional[str] = None, compiled: bool = False, compiled_code: Optional[str] = None, extra_ctes_injected: bool = False, extra_ctes: List[dbt.contracts.graph.nodes.InjectedCTE] = <factory>, _pre_injected_sql: Optional[str] = None, column_name: Optional[str] = None, file_key_name: Optional[str] = None)"
    },
    "TestMetadata": {
      "type": "object",
@@ -2534,6 +2414,7 @@
    "SnapshotNode": {
      "type": "object",
      "required": [
+        "database",
        "schema",
        "name",
        "resource_type",
@@ -2548,14 +2429,7 @@
      ],
      "properties": {
        "database": {
-          "oneOf": [
-            {
-              "type": "string"
-            },
-            {
-              "type": "null"
-            }
-          ]
+          "type": "string"
        },
        "schema": {
          "type": "string"
@@ -2655,7 +2529,7 @@
        },
        "created_at": {
          "type": "number",
-          "default": 1674510977.79998
+          "default": 1670902215.984685
        },
        "config_call_dict": {
          "type": "object",
@@ -2709,16 +2583,6 @@
          },
          "default": []
        },
-        "entities": {
-          "type": "array",
-          "items": {
-            "type": "array",
-            "items": {
-              "type": "string"
-            }
-          },
-          "default": []
-        },
        "depends_on": {
          "$ref": "#/definitions/DependsOn",
          "default": {
@@ -2763,7 +2627,7 @@
        }
      },
      "additionalProperties": false,
-      "description": "SnapshotNode(database: Optional[str], schema: str, name: str, resource_type: dbt.node_types.NodeType, package_name: str, path: str, original_file_path: str, unique_id: str, fqn: List[str], alias: str, checksum: dbt.contracts.files.FileHash, config: dbt.contracts.graph.model_config.SnapshotConfig, _event_status: Dict[str, Any] = <factory>, tags: List[str] = <factory>, description: str = '', columns: Dict[str, dbt.contracts.graph.nodes.ColumnInfo] = <factory>, meta: Dict[str, Any] = <factory>, docs: dbt.contracts.graph.unparsed.Docs = <factory>, patch_path: Optional[str] = None, build_path: Optional[str] = None, deferred: bool = False, unrendered_config: Dict[str, Any] = <factory>, created_at: float = <factory>, config_call_dict: Dict[str, Any] = <factory>, relation_name: Optional[str] = None, raw_code: str = '', language: str = 'sql', refs: List[List[str]] = <factory>, sources: List[List[str]] = <factory>, metrics: List[List[str]] = <factory>, entities: List[List[str]] = <factory>, depends_on: dbt.contracts.graph.nodes.DependsOn = <factory>, compiled_path: Optional[str] = None, compiled: bool = False, compiled_code: Optional[str] = None, extra_ctes_injected: bool = False, extra_ctes: List[dbt.contracts.graph.nodes.InjectedCTE] = <factory>, _pre_injected_sql: Optional[str] = None)"
+      "description": "SnapshotNode(database: str, schema: str, name: str, resource_type: dbt.node_types.NodeType, package_name: str, path: str, original_file_path: str, unique_id: str, fqn: List[str], alias: str, checksum: dbt.contracts.files.FileHash, config: dbt.contracts.graph.model_config.SnapshotConfig, _event_status: Dict[str, Any] = <factory>, tags: List[str] = <factory>, description: str = '', columns: Dict[str, dbt.contracts.graph.nodes.ColumnInfo] = <factory>, meta: Dict[str, Any] = <factory>, docs: dbt.contracts.graph.unparsed.Docs = <factory>, patch_path: Optional[str] = None, build_path: Optional[str] = None, deferred: bool = False, unrendered_config: Dict[str, Any] = <factory>, created_at: float = <factory>, config_call_dict: Dict[str, Any] = <factory>, relation_name: Optional[str] = None, raw_code: str = '', language: str = 'sql', refs: List[List[str]] = <factory>, sources: List[List[str]] = <factory>, metrics: List[List[str]] = <factory>, depends_on: dbt.contracts.graph.nodes.DependsOn = <factory>, compiled_path: Optional[str] = None, compiled: bool = False, compiled_code: Optional[str] = None, extra_ctes_injected: bool = False, extra_ctes: List[dbt.contracts.graph.nodes.InjectedCTE] = <factory>, _pre_injected_sql: Optional[str] = None)"
    },
    "SnapshotConfig": {
      "type": "object",
@@ -2973,6 +2837,7 @@
    "SeedNode": {
      "type": "object",
      "required": [
+        "database",
        "schema",
        "name",
        "resource_type",
@@ -2986,14 +2851,7 @@
      ],
      "properties": {
        "database": {
-          "oneOf": [
-            {
-              "type": "string"
-            },
-            {
-              "type": "null"
-            }
-          ]
+          "type": "string"
        },
        "schema": {
          "type": "string"
@@ -3118,7 +2976,7 @@
        },
        "created_at": {
          "type": "number",
-          "default": 1674510977.801306
+          "default": 1670902215.987447
        },
        "config_call_dict": {
          "type": "object",
@@ -3150,7 +3008,7 @@
        }
      },
      "additionalProperties": false,
-      "description": "SeedNode(database: Optional[str], schema: str, name: str, resource_type: dbt.node_types.NodeType, package_name: str, path: str, original_file_path: str, unique_id: str, fqn: List[str], alias: str, checksum: dbt.contracts.files.FileHash, config: dbt.contracts.graph.model_config.SeedConfig = <factory>, _event_status: Dict[str, Any] = <factory>, tags: List[str] = <factory>, description: str = '', columns: Dict[str, dbt.contracts.graph.nodes.ColumnInfo] = <factory>, meta: Dict[str, Any] = <factory>, docs: dbt.contracts.graph.unparsed.Docs = <factory>, patch_path: Optional[str] = None, build_path: Optional[str] = None, deferred: bool = False, unrendered_config: Dict[str, Any] = <factory>, created_at: float = <factory>, config_call_dict: Dict[str, Any] = <factory>, relation_name: Optional[str] = None, raw_code: str = '', root_path: Optional[str] = None)"
+      "description": "SeedNode(database: str, schema: str, name: str, resource_type: dbt.node_types.NodeType, package_name: str, path: str, original_file_path: str, unique_id: str, fqn: List[str], alias: str, checksum: dbt.contracts.files.FileHash, config: dbt.contracts.graph.model_config.SeedConfig = <factory>, _event_status: Dict[str, Any] = <factory>, tags: List[str] = <factory>, description: str = '', columns: Dict[str, dbt.contracts.graph.nodes.ColumnInfo] = <factory>, meta: Dict[str, Any] = <factory>, docs: dbt.contracts.graph.unparsed.Docs = <factory>, patch_path: Optional[str] = None, build_path: Optional[str] = None, deferred: bool = False, unrendered_config: Dict[str, Any] = <factory>, created_at: float = <factory>, config_call_dict: Dict[str, Any] = <factory>, relation_name: Optional[str] = None, raw_code: str = '', root_path: Optional[str] = None)"
    },
    "SeedConfig": {
      "type": "object",
@@ -3320,6 +3178,7 @@
    "SourceDefinition": {
      "type": "object",
      "required": [
+        "database",
        "schema",
        "name",
        "resource_type",
@@ -3335,14 +3194,7 @@
      ],
      "properties": {
        "database": {
-          "oneOf": [
-            {
-              "type": "string"
-            },
-            {
-              "type": "null"
-            }
-          ]
+          "type": "string"
        },
        "schema": {
          "type": "string"
@@ -3483,11 +3335,11 @@
        },
        "created_at": {
          "type": "number",
-          "default": 1674510977.802621
+          "default": 1670902215.989922
        }
      },
      "additionalProperties": false,
-      "description": "SourceDefinition(database: Optional[str], schema: str, name: str, resource_type: dbt.node_types.NodeType, package_name: str, path: str, original_file_path: str, unique_id: str, fqn: List[str], source_name: str, source_description: str, loader: str, identifier: str, _event_status: Dict[str, Any] = <factory>, quoting: dbt.contracts.graph.unparsed.Quoting = <factory>, loaded_at_field: Optional[str] = None, freshness: Optional[dbt.contracts.graph.unparsed.FreshnessThreshold] = None, external: Optional[dbt.contracts.graph.unparsed.ExternalTable] = None, description: str = '', columns: Dict[str, dbt.contracts.graph.nodes.ColumnInfo] = <factory>, meta: Dict[str, Any] = <factory>, source_meta: Dict[str, Any] = <factory>, tags: List[str] = <factory>, config: dbt.contracts.graph.model_config.SourceConfig = <factory>, patch_path: Optional[str] = None, unrendered_config: Dict[str, Any] = <factory>, relation_name: Optional[str] = None, created_at: float = <factory>)"
+      "description": "SourceDefinition(database: str, schema: str, name: str, resource_type: dbt.node_types.NodeType, package_name: str, path: str, original_file_path: str, unique_id: str, fqn: List[str], source_name: str, source_description: str, loader: str, identifier: str, _event_status: Dict[str, Any] = <factory>, quoting: dbt.contracts.graph.unparsed.Quoting = <factory>, loaded_at_field: Optional[str] = None, freshness: Optional[dbt.contracts.graph.unparsed.FreshnessThreshold] = None, external: Optional[dbt.contracts.graph.unparsed.ExternalTable] = None, description: str = '', columns: Dict[str, dbt.contracts.graph.nodes.ColumnInfo] = <factory>, meta: Dict[str, Any] = <factory>, source_meta: Dict[str, Any] = <factory>, tags: List[str] = <factory>, config: dbt.contracts.graph.model_config.SourceConfig = <factory>, patch_path: Optional[str] = None, unrendered_config: Dict[str, Any] = <factory>, relation_name: Optional[str] = None, created_at: float = <factory>)"
    },
    "Quoting": {
      "type": "object",
@@ -3593,12 +3445,12 @@
        },
        "dbt_version": {
          "type": "string",
-          "default": "1.5.0a1"
+          "default": "1.4.0a1"
        },
        "generated_at": {
          "type": "string",
          "format": "date-time",
-          "default": "2023-01-23T21:56:17.787436Z"
+          "default": "2022-12-13T03:30:15.961825Z"
        },
        "invocation_id": {
          "oneOf": [
@@ -3609,7 +3461,7 @@
              "type": "null"
            }
          ],
-          "default": "10c9c26b-6682-4d46-84d2-12f641a070e5"
+          "default": "4f2b967b-7e02-46de-a7ea-268a05e3fab1"
        },
        "env": {
          "type": "object",
@@ -3620,7 +3472,7 @@
        }
      },
      "additionalProperties": false,
-      "description": "FreshnessMetadata(dbt_schema_version: str = <factory>, dbt_version: str = '1.5.0a1', generated_at: datetime.datetime = <factory>, invocation_id: Optional[str] = <factory>, env: Dict[str, str] = <factory>)"
+      "description": "FreshnessMetadata(dbt_schema_version: str = <factory>, dbt_version: str = '1.4.0a1', generated_at: datetime.datetime = <factory>, invocation_id: Optional[str] = <factory>, env: Dict[str, str] = <factory>)"
    },
    "SourceFreshnessRuntimeError": {
      "type": "object",
@@ -3962,7 +3814,7 @@
        },
        "created_at": {
          "type": "number",
-          "default": 1674510977.8031092
+          "default": 1670902215.990816
        },
        "supported_languages": {
          "oneOf": [
@@ -4218,23 +4070,13 @@
          },
          "default": []
        },
-        "entities": {
-          "type": "array",
-          "items": {
-            "type": "array",
-            "items": {
-              "type": "string"
-            }
-          },
-          "default": []
-        },
        "created_at": {
          "type": "number",
-          "default": 1674510977.8040562
+          "default": 1670902215.993354
        }
      },
      "additionalProperties": false,
-      "description": "Exposure(name: str, resource_type: dbt.node_types.NodeType, package_name: str, path: str, original_file_path: str, unique_id: str, fqn: List[str], type: dbt.contracts.graph.unparsed.ExposureType, owner: dbt.contracts.graph.unparsed.ExposureOwner, description: str = '', label: Optional[str] = None, maturity: Optional[dbt.contracts.graph.unparsed.MaturityType] = None, meta: Dict[str, Any] = <factory>, tags: List[str] = <factory>, config: dbt.contracts.graph.model_config.ExposureConfig = <factory>, unrendered_config: Dict[str, Any] = <factory>, url: Optional[str] = None, depends_on: dbt.contracts.graph.nodes.DependsOn = <factory>, refs: List[List[str]] = <factory>, sources: List[List[str]] = <factory>, metrics: List[List[str]] = <factory>, entities: List[List[str]] = <factory>, created_at: float = <factory>)"
+      "description": "Exposure(name: str, resource_type: dbt.node_types.NodeType, package_name: str, path: str, original_file_path: str, unique_id: str, fqn: List[str], type: dbt.contracts.graph.unparsed.ExposureType, owner: dbt.contracts.graph.unparsed.ExposureOwner, description: str = '', label: Optional[str] = None, maturity: Optional[dbt.contracts.graph.unparsed.MaturityType] = None, meta: Dict[str, Any] = <factory>, tags: List[str] = <factory>, config: dbt.contracts.graph.model_config.ExposureConfig = <factory>, unrendered_config: Dict[str, Any] = <factory>, url: Optional[str] = None, depends_on: dbt.contracts.graph.nodes.DependsOn = <factory>, refs: List[List[str]] = <factory>, sources: List[List[str]] = <factory>, metrics: List[List[str]] = <factory>, created_at: float = <factory>)"
    },
    "ExposureOwner": {
      "type": "object",
@@ -4284,6 +4126,7 @@
        "description",
        "label",
        "calculation_method",
+        "timestamp",
        "expression",
        "filters",
        "time_grains",
@@ -4326,6 +4169,9 @@
        "calculation_method": {
          "type": "string"
        },
+        "timestamp": {
+          "type": "string"
+        },
        "expression": {
          "type": "string"
        },
@@ -4347,16 +4193,6 @@
            "type": "string"
          }
        },
-        "timestamp": {
-          "oneOf": [
-            {
-              "type": "string"
-            },
-            {
-              "type": "null"
-            }
-          ]
-        },
        "window": {
          "oneOf": [
            {
@@ -4445,23 +4281,13 @@
          },
          "default": []
        },
-        "entities": {
-          "type": "array",
-          "items": {
-            "type": "array",
-            "items": {
-              "type": "string"
-            }
-          },
-          "default": []
-        },
        "created_at": {
          "type": "number",
-          "default": 1674510977.804972
+          "default": 1670902215.995033
        }
      },
      "additionalProperties": false,
-      "description": "Metric(name: str, resource_type: dbt.node_types.NodeType, package_name: str, path: str, original_file_path: str, unique_id: str, fqn: List[str], description: str, label: str, calculation_method: str, expression: str, filters: List[dbt.contracts.graph.unparsed.MetricFilter], time_grains: List[str], dimensions: List[str], timestamp: Optional[str] = None, window: Optional[dbt.contracts.graph.unparsed.MetricTime] = None, model: Optional[str] = None, model_unique_id: Optional[str] = None, meta: Dict[str, Any] = <factory>, tags: List[str] = <factory>, config: dbt.contracts.graph.model_config.MetricConfig = <factory>, unrendered_config: Dict[str, Any] = <factory>, sources: List[List[str]] = <factory>, depends_on: dbt.contracts.graph.nodes.DependsOn = <factory>, refs: List[List[str]] = <factory>, metrics: List[List[str]] = <factory>, entities: List[List[str]] = <factory>, created_at: float = <factory>)"
+      "description": "Metric(name: str, resource_type: dbt.node_types.NodeType, package_name: str, path: str, original_file_path: str, unique_id: str, fqn: List[str], description: str, label: str, calculation_method: str, timestamp: str, expression: str, filters: List[dbt.contracts.graph.unparsed.MetricFilter], time_grains: List[str], dimensions: List[str], window: Optional[dbt.contracts.graph.unparsed.MetricTime] = None, model: Optional[str] = None, model_unique_id: Optional[str] = None, meta: Dict[str, Any] = <factory>, tags: List[str] = <factory>, config: dbt.contracts.graph.model_config.MetricConfig = <factory>, unrendered_config: Dict[str, Any] = <factory>, sources: List[List[str]] = <factory>, depends_on: dbt.contracts.graph.nodes.DependsOn = <factory>, refs: List[List[str]] = <factory>, metrics: List[List[str]] = <factory>, created_at: float = <factory>)"
    },
    "MetricFilter": {
      "type": "object",
@@ -4529,148 +4355,6 @@
      },
      "additionalProperties": true,
      "description": "MetricConfig(_extra: Dict[str, Any] = <factory>, enabled: bool = True)"
-    },
-    "Entity": {
-      "type": "object",
-      "required": [
-        "name",
-        "resource_type",
-        "package_name",
-        "path",
-        "original_file_path",
-        "unique_id",
-        "fqn",
-        "model",
-        "description",
-        "dimensions"
-      ],
-      "properties": {
-        "name": {
-          "type": "string"
-        },
-        "resource_type": {
-          "type": "string",
-          "enum": [
-            "entity"
-          ]
-        },
-        "package_name": {
-          "type": "string"
-        },
-        "path": {
-          "type": "string"
-        },
-        "original_file_path": {
-          "type": "string"
-        },
-        "unique_id": {
-          "type": "string"
-        },
-        "fqn": {
-          "type": "array",
-          "items": {
-            "type": "string"
-          }
-        },
-        "model": {
-          "type": "string"
-        },
-        "description": {
-          "type": "string"
-        },
-        "dimensions": {
-          "type": "array",
-          "items": {
-            "type": "string"
-          }
-        },
-        "model_unique_id": {
-          "oneOf": [
-            {
-              "type": "string"
-            },
-            {
-              "type": "null"
-            }
-          ]
-        },
-        "meta": {
-          "type": "object",
-          "default": {}
-        },
-        "tags": {
-          "type": "array",
-          "items": {
-            "type": "string"
-          },
-          "default": []
-        },
-        "config": {
-          "$ref": "#/definitions/EntityConfig",
-          "default": {
-            "enabled": true
-          }
-        },
-        "unrendered_config": {
-          "type": "object",
-          "default": {}
-        },
-        "sources": {
-          "type": "array",
-          "items": {
-            "type": "array",
-            "items": {
-              "type": "string"
-            }
-          },
-          "default": []
-        },
-        "depends_on": {
-          "$ref": "#/definitions/DependsOn",
-          "default": {
-            "macros": [],
-            "nodes": []
-          }
-        },
-        "refs": {
-          "type": "array",
-          "items": {
-            "type": "array",
-            "items": {
-              "type": "string"
-            }
-          },
-          "default": []
-        },
-        "entities": {
-          "type": "array",
-          "items": {
-            "type": "array",
-            "items": {
-              "type": "string"
-            }
-          },
-          "default": []
-        },
-        "created_at": {
-          "type": "number",
-          "default": 1674510977.805523
-        }
-      },
-      "additionalProperties": false,
-      "description": "Entity(name: str, resource_type: dbt.node_types.NodeType, package_name: str, path: str, original_file_path: str, unique_id: str, fqn: List[str], model: str, description: str, dimensions: List[str], model_unique_id: Optional[str] = None, meta: Dict[str, Any] = <factory>, tags: List[str] = <factory>, config: dbt.contracts.graph.model_config.EntityConfig = <factory>, unrendered_config: Dict[str, Any] = <factory>, sources: List[List[str]] = <factory>, depends_on: dbt.contracts.graph.nodes.DependsOn = <factory>, refs: List[List[str]] = <factory>, entities: List[List[str]] = <factory>, created_at: float = <factory>)"
-    },
-    "EntityConfig": {
-      "type": "object",
-      "required": [],
-      "properties": {
-        "enabled": {
-          "type": "boolean",
-          "default": true
-        }
-      },
-      "additionalProperties": true,
-      "description": "EntityConfig(_extra: Dict[str, Any] = <factory>, enabled: bool = True)"
    }
  },
  "$schema": "http://json-schema.org/draft-07/schema#",
--- a/schemas/dbt/run-results/v4.json
+++ b/schemas/dbt/run-results/v4.json
@@ -37,12 +37,12 @@
        },
        "dbt_version": {
          "type": "string",
-          "default": "1.5.0a1"
+          "default": "1.2.0a1"
        },
        "generated_at": {
          "type": "string",
          "format": "date-time",
-          "default": "2023-01-23T21:56:17.788708Z"
+          "default": "2022-04-15T20:38:22.700175Z"
        },
        "invocation_id": {
          "oneOf": [
@@ -53,7 +53,7 @@
              "type": "null"
            }
          ],
-          "default": "10c9c26b-6682-4d46-84d2-12f641a070e5"
+          "default": "34abf75e-59d3-442f-920c-fa3843d98014"
        },
        "env": {
          "type": "object",
@@ -64,7 +64,7 @@
        }
      },
      "additionalProperties": false,
-      "description": "BaseArtifactMetadata(dbt_schema_version: str, dbt_version: str = '1.5.0a1', generated_at: datetime.datetime = <factory>, invocation_id: Optional[str] = <factory>, env: Dict[str, str] = <factory>)"
+      "description": "BaseArtifactMetadata(dbt_schema_version: str, dbt_version: str = '1.2.0a1', generated_at: datetime.datetime = <factory>, invocation_id: Union[str, NoneType] = <factory>, env: Dict[str, str] = <factory>)"
    },
    "RunResultOutput": {
      "type": "object",
@@ -148,7 +148,7 @@
        }
      },
      "additionalProperties": false,
-      "description": "RunResultOutput(status: Union[dbt.contracts.results.RunStatus, dbt.contracts.results.TestStatus, dbt.contracts.results.FreshnessStatus], timing: List[dbt.contracts.results.TimingInfo], thread_id: str, execution_time: float, adapter_response: Dict[str, Any], message: Optional[str], failures: Optional[int], unique_id: str)"
+      "description": "RunResultOutput(status: Union[dbt.contracts.results.RunStatus, dbt.contracts.results.TestStatus, dbt.contracts.results.FreshnessStatus], timing: List[dbt.contracts.results.TimingInfo], thread_id: str, execution_time: float, adapter_response: Dict[str, Any], message: Union[str, NoneType], failures: Union[int, NoneType], unique_id: str)"
    },
    "TimingInfo": {
      "type": "object",
@@ -183,7 +183,7 @@
        }
      },
      "additionalProperties": false,
-      "description": "TimingInfo(name: str, started_at: Optional[datetime.datetime] = None, completed_at: Optional[datetime.datetime] = None)"
+      "description": "TimingInfo(name: str, started_at: Union[datetime.datetime, NoneType] = None, completed_at: Union[datetime.datetime, NoneType] = None)"
    },
    "FreshnessMetadata": {
      "type": "object",
@@ -195,12 +195,12 @@
        },
        "dbt_version": {
          "type": "string",
-          "default": "1.5.0a1"
+          "default": "1.2.0a1"
        },
        "generated_at": {
          "type": "string",
          "format": "date-time",
-          "default": "2023-01-23T21:56:17.787436Z"
+          "default": "2022-04-15T20:38:22.697740Z"
        },
        "invocation_id": {
          "oneOf": [
@@ -211,7 +211,7 @@
              "type": "null"
            }
          ],
-          "default": "10c9c26b-6682-4d46-84d2-12f641a070e5"
+          "default": "34abf75e-59d3-442f-920c-fa3843d98014"
        },
        "env": {
          "type": "object",
@@ -222,7 +222,7 @@
        }
      },
      "additionalProperties": false,
-      "description": "FreshnessMetadata(dbt_schema_version: str = <factory>, dbt_version: str = '1.5.0a1', generated_at: datetime.datetime = <factory>, invocation_id: Optional[str] = <factory>, env: Dict[str, str] = <factory>)"
+      "description": "FreshnessMetadata(dbt_schema_version: str = <factory>, dbt_version: str = '1.2.0a1', generated_at: datetime.datetime = <factory>, invocation_id: Union[str, NoneType] = <factory>, env: Dict[str, str] = <factory>)"
    },
    "SourceFreshnessRuntimeError": {
      "type": "object",
@@ -361,7 +361,7 @@
        }
      },
      "additionalProperties": false,
-      "description": "FreshnessThreshold(warn_after: Optional[dbt.contracts.graph.unparsed.Time] = <factory>, error_after: Optional[dbt.contracts.graph.unparsed.Time] = <factory>, filter: Optional[str] = None)"
+      "description": "FreshnessThreshold(warn_after: Union[dbt.contracts.graph.unparsed.Time, NoneType] = <factory>, error_after: Union[dbt.contracts.graph.unparsed.Time, NoneType] = <factory>, filter: Union[str, NoneType] = None)"
    },
    "Time": {
      "type": "object",
@@ -394,7 +394,7 @@
        }
      },
      "additionalProperties": false,
-      "description": "Time(count: Optional[int] = None, period: Optional[dbt.contracts.graph.unparsed.TimePeriod] = None)"
+      "description": "Time(count: Union[int, NoneType] = None, period: Union[dbt.contracts.graph.unparsed.TimePeriod, NoneType] = None)"
    }
  },
  "$schema": "http://json-schema.org/draft-07/schema#",
--- a/schemas/dbt/sources/v3.json
+++ b/schemas/dbt/sources/v3.json
@@ -39,12 +39,12 @@
        },
        "dbt_version": {
          "type": "string",
-          "default": "1.5.0a1"
+          "default": "1.2.0a1"
        },
        "generated_at": {
          "type": "string",
          "format": "date-time",
-          "default": "2023-01-23T21:56:17.787436Z"
+          "default": "2022-04-15T20:38:22.697740Z"
        },
        "invocation_id": {
          "oneOf": [
@@ -55,7 +55,7 @@
              "type": "null"
            }
          ],
-          "default": "10c9c26b-6682-4d46-84d2-12f641a070e5"
+          "default": "34abf75e-59d3-442f-920c-fa3843d98014"
        },
        "env": {
          "type": "object",
@@ -66,7 +66,7 @@
        }
      },
      "additionalProperties": false,
-      "description": "FreshnessMetadata(dbt_schema_version: str = <factory>, dbt_version: str = '1.5.0a1', generated_at: datetime.datetime = <factory>, invocation_id: Optional[str] = <factory>, env: Dict[str, str] = <factory>)"
+      "description": "FreshnessMetadata(dbt_schema_version: str = <factory>, dbt_version: str = '1.2.0a1', generated_at: datetime.datetime = <factory>, invocation_id: Union[str, NoneType] = <factory>, env: Dict[str, str] = <factory>)"
    },
    "SourceFreshnessRuntimeError": {
      "type": "object",
@@ -205,7 +205,7 @@
        }
      },
      "additionalProperties": false,
-      "description": "FreshnessThreshold(warn_after: Optional[dbt.contracts.graph.unparsed.Time] = <factory>, error_after: Optional[dbt.contracts.graph.unparsed.Time] = <factory>, filter: Optional[str] = None)"
+      "description": "FreshnessThreshold(warn_after: Union[dbt.contracts.graph.unparsed.Time, NoneType] = <factory>, error_after: Union[dbt.contracts.graph.unparsed.Time, NoneType] = <factory>, filter: Union[str, NoneType] = None)"
    },
    "Time": {
      "type": "object",
@@ -238,7 +238,7 @@
        }
      },
      "additionalProperties": false,
-      "description": "Time(count: Optional[int] = None, period: Optional[dbt.contracts.graph.unparsed.TimePeriod] = None)"
+      "description": "Time(count: Union[int, NoneType] = None, period: Union[dbt.contracts.graph.unparsed.TimePeriod, NoneType] = None)"
    },
    "TimingInfo": {
      "type": "object",
@@ -273,7 +273,7 @@
        }
      },
      "additionalProperties": false,
-      "description": "TimingInfo(name: str, started_at: Optional[datetime.datetime] = None, completed_at: Optional[datetime.datetime] = None)"
+      "description": "TimingInfo(name: str, started_at: Union[datetime.datetime, NoneType] = None, completed_at: Union[datetime.datetime, NoneType] = None)"
    }
  },
  "$schema": "http://json-schema.org/draft-07/schema#",
--- a/test/integration/018_adapter_ddl_tests/models/materialized.sql
+++ b/test/integration/018_adapter_ddl_tests/models/materialized.sql
@@ -0,0 +1,9 @@
+{{
+  config(
+    materialized = "table",
+    sort = 'first_name',
+    dist = 'first_name'
+  )
+}}
+
+select * from {{ this.schema }}.seed
--- a/test/integration/018_adapter_ddl_tests/seed.sql
+++ b/test/integration/018_adapter_ddl_tests/seed.sql
@@ -0,0 +1,110 @@
+create table {schema}.seed (
+	id BIGSERIAL PRIMARY KEY,
+	first_name VARCHAR(50),
+	last_name VARCHAR(50),
+	email VARCHAR(50),
+	gender VARCHAR(50),
+	ip_address VARCHAR(20)
+);
+
+
+insert into {schema}.seed (first_name, last_name, email, gender, ip_address) values ('Jack', 'Hunter', 'jhunter0@pbs.org', 'Male', '59.80.20.168');
+insert into {schema}.seed (first_name, last_name, email, gender, ip_address) values ('Kathryn', 'Walker', 'kwalker1@ezinearticles.com', 'Female', '194.121.179.35');
+insert into {schema}.seed (first_name, last_name, email, gender, ip_address) values ('Gerald', 'Ryan', 'gryan2@com.com', 'Male', '11.3.212.243');
+insert into {schema}.seed (first_name, last_name, email, gender, ip_address) values ('Bonnie', 'Spencer', 'bspencer3@ameblo.jp', 'Female', '216.32.196.175');
+insert into {schema}.seed (first_name, last_name, email, gender, ip_address) values ('Harold', 'Taylor', 'htaylor4@people.com.cn', 'Male', '253.10.246.136');
+insert into {schema}.seed (first_name, last_name, email, gender, ip_address) values ('Jacqueline', 'Griffin', 'jgriffin5@t.co', 'Female', '16.13.192.220');
+insert into {schema}.seed (first_name, last_name, email, gender, ip_address) values ('Wanda', 'Arnold', 'warnold6@google.nl', 'Female', '232.116.150.64');
+insert into {schema}.seed (first_name, last_name, email, gender, ip_address) values ('Craig', 'Ortiz', 'cortiz7@sciencedaily.com', 'Male', '199.126.106.13');
+insert into {schema}.seed (first_name, last_name, email, gender, ip_address) values ('Gary', 'Day', 'gday8@nih.gov', 'Male', '35.81.68.186');
+insert into {schema}.seed (first_name, last_name, email, gender, ip_address) values ('Rose', 'Wright', 'rwright9@yahoo.co.jp', 'Female', '236.82.178.100');
+insert into {schema}.seed (first_name, last_name, email, gender, ip_address) values ('Raymond', 'Kelley', 'rkelleya@fc2.com', 'Male', '213.65.166.67');
+insert into {schema}.seed (first_name, last_name, email, gender, ip_address) values ('Gerald', 'Robinson', 'grobinsonb@disqus.com', 'Male', '72.232.194.193');
+insert into {schema}.seed (first_name, last_name, email, gender, ip_address) values ('Mildred', 'Martinez', 'mmartinezc@samsung.com', 'Female', '198.29.112.5');
+insert into {schema}.seed (first_name, last_name, email, gender, ip_address) values ('Dennis', 'Arnold', 'darnoldd@google.com', 'Male', '86.96.3.250');
+insert into {schema}.seed (first_name, last_name, email, gender, ip_address) values ('Judy', 'Gray', 'jgraye@opensource.org', 'Female', '79.218.162.245');
+insert into {schema}.seed (first_name, last_name, email, gender, ip_address) values ('Theresa', 'Garza', 'tgarzaf@epa.gov', 'Female', '21.59.100.54');
+insert into {schema}.seed (first_name, last_name, email, gender, ip_address) values ('Gerald', 'Robertson', 'grobertsong@csmonitor.com', 'Male', '131.134.82.96');
+insert into {schema}.seed (first_name, last_name, email, gender, ip_address) values ('Philip', 'Hernandez', 'phernandezh@adobe.com', 'Male', '254.196.137.72');
+insert into {schema}.seed (first_name, last_name, email, gender, ip_address) values ('Julia', 'Gonzalez', 'jgonzalezi@cam.ac.uk', 'Female', '84.240.227.174');
+insert into {schema}.seed (first_name, last_name, email, gender, ip_address) values ('Andrew', 'Davis', 'adavisj@patch.com', 'Male', '9.255.67.25');
+insert into {schema}.seed (first_name, last_name, email, gender, ip_address) values ('Kimberly', 'Harper', 'kharperk@foxnews.com', 'Female', '198.208.120.253');
+insert into {schema}.seed (first_name, last_name, email, gender, ip_address) values ('Mark', 'Martin', 'mmartinl@marketwatch.com', 'Male', '233.138.182.153');
+insert into {schema}.seed (first_name, last_name, email, gender, ip_address) values ('Cynthia', 'Ruiz', 'cruizm@google.fr', 'Female', '18.178.187.201');
+insert into {schema}.seed (first_name, last_name, email, gender, ip_address) values ('Samuel', 'Carroll', 'scarrolln@youtu.be', 'Male', '128.113.96.122');
+insert into {schema}.seed (first_name, last_name, email, gender, ip_address) values ('Jennifer', 'Larson', 'jlarsono@vinaora.com', 'Female', '98.234.85.95');
+insert into {schema}.seed (first_name, last_name, email, gender, ip_address) values ('Ashley', 'Perry', 'aperryp@rakuten.co.jp', 'Female', '247.173.114.52');
+insert into {schema}.seed (first_name, last_name, email, gender, ip_address) values ('Howard', 'Rodriguez', 'hrodriguezq@shutterfly.com', 'Male', '231.188.95.26');
+insert into {schema}.seed (first_name, last_name, email, gender, ip_address) values ('Amy', 'Brooks', 'abrooksr@theatlantic.com', 'Female', '141.199.174.118');
+insert into {schema}.seed (first_name, last_name, email, gender, ip_address) values ('Louise', 'Warren', 'lwarrens@adobe.com', 'Female', '96.105.158.28');
+insert into {schema}.seed (first_name, last_name, email, gender, ip_address) values ('Tina', 'Watson', 'twatsont@myspace.com', 'Female', '251.142.118.177');
+insert into {schema}.seed (first_name, last_name, email, gender, ip_address) values ('Janice', 'Kelley', 'jkelleyu@creativecommons.org', 'Female', '239.167.34.233');
+insert into {schema}.seed (first_name, last_name, email, gender, ip_address) values ('Terry', 'Mccoy', 'tmccoyv@bravesites.com', 'Male', '117.201.183.203');
+insert into {schema}.seed (first_name, last_name, email, gender, ip_address) values ('Jeffrey', 'Morgan', 'jmorganw@surveymonkey.com', 'Male', '78.101.78.149');
+insert into {schema}.seed (first_name, last_name, email, gender, ip_address) values ('Louis', 'Harvey', 'lharveyx@sina.com.cn', 'Male', '51.50.0.167');
+insert into {schema}.seed (first_name, last_name, email, gender, ip_address) values ('Philip', 'Miller', 'pmillery@samsung.com', 'Male', '103.255.222.110');
+insert into {schema}.seed (first_name, last_name, email, gender, ip_address) values ('Willie', 'Marshall', 'wmarshallz@ow.ly', 'Male', '149.219.91.68');
+insert into {schema}.seed (first_name, last_name, email, gender, ip_address) values ('Patrick', 'Lopez', 'plopez10@redcross.org', 'Male', '250.136.229.89');
+insert into {schema}.seed (first_name, last_name, email, gender, ip_address) values ('Adam', 'Jenkins', 'ajenkins11@harvard.edu', 'Male', '7.36.112.81');
+insert into {schema}.seed (first_name, last_name, email, gender, ip_address) values ('Benjamin', 'Cruz', 'bcruz12@linkedin.com', 'Male', '32.38.98.15');
+insert into {schema}.seed (first_name, last_name, email, gender, ip_address) values ('Ruby', 'Hawkins', 'rhawkins13@gmpg.org', 'Female', '135.171.129.255');
+insert into {schema}.seed (first_name, last_name, email, gender, ip_address) values ('Carlos', 'Barnes', 'cbarnes14@a8.net', 'Male', '240.197.85.140');
+insert into {schema}.seed (first_name, last_name, email, gender, ip_address) values ('Ruby', 'Griffin', 'rgriffin15@bravesites.com', 'Female', '19.29.135.24');
+insert into {schema}.seed (first_name, last_name, email, gender, ip_address) values ('Sean', 'Mason', 'smason16@icq.com', 'Male', '159.219.155.249');
+insert into {schema}.seed (first_name, last_name, email, gender, ip_address) values ('Anthony', 'Payne', 'apayne17@utexas.edu', 'Male', '235.168.199.218');
+insert into {schema}.seed (first_name, last_name, email, gender, ip_address) values ('Steve', 'Cruz', 'scruz18@pcworld.com', 'Male', '238.201.81.198');
+insert into {schema}.seed (first_name, last_name, email, gender, ip_address) values ('Anthony', 'Garcia', 'agarcia19@flavors.me', 'Male', '25.85.10.18');
+insert into {schema}.seed (first_name, last_name, email, gender, ip_address) values ('Doris', 'Lopez', 'dlopez1a@sphinn.com', 'Female', '245.218.51.238');
+insert into {schema}.seed (first_name, last_name, email, gender, ip_address) values ('Susan', 'Nichols', 'snichols1b@freewebs.com', 'Female', '199.99.9.61');
+insert into {schema}.seed (first_name, last_name, email, gender, ip_address) values ('Wanda', 'Ferguson', 'wferguson1c@yahoo.co.jp', 'Female', '236.241.135.21');
+insert into {schema}.seed (first_name, last_name, email, gender, ip_address) values ('Andrea', 'Pierce', 'apierce1d@google.co.uk', 'Female', '132.40.10.209');
+insert into {schema}.seed (first_name, last_name, email, gender, ip_address) values ('Lawrence', 'Phillips', 'lphillips1e@jugem.jp', 'Male', '72.226.82.87');
+insert into {schema}.seed (first_name, last_name, email, gender, ip_address) values ('Judy', 'Gilbert', 'jgilbert1f@multiply.com', 'Female', '196.250.15.142');
+insert into {schema}.seed (first_name, last_name, email, gender, ip_address) values ('Eric', 'Williams', 'ewilliams1g@joomla.org', 'Male', '222.202.73.126');
+insert into {schema}.seed (first_name, last_name, email, gender, ip_address) values ('Ralph', 'Romero', 'rromero1h@sogou.com', 'Male', '123.184.125.212');
+insert into {schema}.seed (first_name, last_name, email, gender, ip_address) values ('Jean', 'Wilson', 'jwilson1i@ocn.ne.jp', 'Female', '176.106.32.194');
+insert into {schema}.seed (first_name, last_name, email, gender, ip_address) values ('Lori', 'Reynolds', 'lreynolds1j@illinois.edu', 'Female', '114.181.203.22');
+insert into {schema}.seed (first_name, last_name, email, gender, ip_address) values ('Donald', 'Moreno', 'dmoreno1k@bbc.co.uk', 'Male', '233.249.97.60');
+insert into {schema}.seed (first_name, last_name, email, gender, ip_address) values ('Steven', 'Berry', 'sberry1l@eepurl.com', 'Male', '186.193.50.50');
+insert into {schema}.seed (first_name, last_name, email, gender, ip_address) values ('Theresa', 'Shaw', 'tshaw1m@people.com.cn', 'Female', '120.37.71.222');
+insert into {schema}.seed (first_name, last_name, email, gender, ip_address) values ('John', 'Stephens', 'jstephens1n@nationalgeographic.com', 'Male', '191.87.127.115');
+insert into {schema}.seed (first_name, last_name, email, gender, ip_address) values ('Richard', 'Jacobs', 'rjacobs1o@state.tx.us', 'Male', '66.210.83.155');
+insert into {schema}.seed (first_name, last_name, email, gender, ip_address) values ('Andrew', 'Lawson', 'alawson1p@over-blog.com', 'Male', '54.98.36.94');
+insert into {schema}.seed (first_name, last_name, email, gender, ip_address) values ('Peter', 'Morgan', 'pmorgan1q@rambler.ru', 'Male', '14.77.29.106');
+insert into {schema}.seed (first_name, last_name, email, gender, ip_address) values ('Nicole', 'Garrett', 'ngarrett1r@zimbio.com', 'Female', '21.127.74.68');
+insert into {schema}.seed (first_name, last_name, email, gender, ip_address) values ('Joshua', 'Kim', 'jkim1s@edublogs.org', 'Male', '57.255.207.41');
+insert into {schema}.seed (first_name, last_name, email, gender, ip_address) values ('Ralph', 'Roberts', 'rroberts1t@people.com.cn', 'Male', '222.143.131.109');
+insert into {schema}.seed (first_name, last_name, email, gender, ip_address) values ('George', 'Montgomery', 'gmontgomery1u@smugmug.com', 'Male', '76.75.111.77');
+insert into {schema}.seed (first_name, last_name, email, gender, ip_address) values ('Gerald', 'Alvarez', 'galvarez1v@flavors.me', 'Male', '58.157.186.194');
+insert into {schema}.seed (first_name, last_name, email, gender, ip_address) values ('Donald', 'Olson', 'dolson1w@whitehouse.gov', 'Male', '69.65.74.135');
+insert into {schema}.seed (first_name, last_name, email, gender, ip_address) values ('Carlos', 'Morgan', 'cmorgan1x@pbs.org', 'Male', '96.20.140.87');
+insert into {schema}.seed (first_name, last_name, email, gender, ip_address) values ('Aaron', 'Stanley', 'astanley1y@webnode.com', 'Male', '163.119.217.44');
+insert into {schema}.seed (first_name, last_name, email, gender, ip_address) values ('Virginia', 'Long', 'vlong1z@spiegel.de', 'Female', '204.150.194.182');
+insert into {schema}.seed (first_name, last_name, email, gender, ip_address) values ('Robert', 'Berry', 'rberry20@tripadvisor.com', 'Male', '104.19.48.241');
+insert into {schema}.seed (first_name, last_name, email, gender, ip_address) values ('Antonio', 'Brooks', 'abrooks21@unesco.org', 'Male', '210.31.7.24');
+insert into {schema}.seed (first_name, last_name, email, gender, ip_address) values ('Ruby', 'Garcia', 'rgarcia22@ovh.net', 'Female', '233.218.162.214');
+insert into {schema}.seed (first_name, last_name, email, gender, ip_address) values ('Jack', 'Hanson', 'jhanson23@blogtalkradio.com', 'Male', '31.55.46.199');
+insert into {schema}.seed (first_name, last_name, email, gender, ip_address) values ('Kathryn', 'Nelson', 'knelson24@walmart.com', 'Female', '14.189.146.41');
+insert into {schema}.seed (first_name, last_name, email, gender, ip_address) values ('Jason', 'Reed', 'jreed25@printfriendly.com', 'Male', '141.189.89.255');
+insert into {schema}.seed (first_name, last_name, email, gender, ip_address) values ('George', 'Coleman', 'gcoleman26@people.com.cn', 'Male', '81.189.221.144');
+insert into {schema}.seed (first_name, last_name, email, gender, ip_address) values ('Rose', 'King', 'rking27@ucoz.com', 'Female', '212.123.168.231');
+insert into {schema}.seed (first_name, last_name, email, gender, ip_address) values ('Johnny', 'Holmes', 'jholmes28@boston.com', 'Male', '177.3.93.188');
+insert into {schema}.seed (first_name, last_name, email, gender, ip_address) values ('Katherine', 'Gilbert', 'kgilbert29@altervista.org', 'Female', '199.215.169.61');
+insert into {schema}.seed (first_name, last_name, email, gender, ip_address) values ('Joshua', 'Thomas', 'jthomas2a@ustream.tv', 'Male', '0.8.205.30');
+insert into {schema}.seed (first_name, last_name, email, gender, ip_address) values ('Julie', 'Perry', 'jperry2b@opensource.org', 'Female', '60.116.114.192');
+insert into {schema}.seed (first_name, last_name, email, gender, ip_address) values ('Richard', 'Perry', 'rperry2c@oracle.com', 'Male', '181.125.70.232');
+insert into {schema}.seed (first_name, last_name, email, gender, ip_address) values ('Kenneth', 'Ruiz', 'kruiz2d@wikimedia.org', 'Male', '189.105.137.109');
+insert into {schema}.seed (first_name, last_name, email, gender, ip_address) values ('Jose', 'Morgan', 'jmorgan2e@webnode.com', 'Male', '101.134.215.156');
+insert into {schema}.seed (first_name, last_name, email, gender, ip_address) values ('Donald', 'Campbell', 'dcampbell2f@goo.ne.jp', 'Male', '102.120.215.84');
+insert into {schema}.seed (first_name, last_name, email, gender, ip_address) values ('Debra', 'Collins', 'dcollins2g@uol.com.br', 'Female', '90.13.153.235');
+insert into {schema}.seed (first_name, last_name, email, gender, ip_address) values ('Jesse', 'Johnson', 'jjohnson2h@stumbleupon.com', 'Male', '225.178.125.53');
+insert into {schema}.seed (first_name, last_name, email, gender, ip_address) values ('Elizabeth', 'Stone', 'estone2i@histats.com', 'Female', '123.184.126.221');
+insert into {schema}.seed (first_name, last_name, email, gender, ip_address) values ('Angela', 'Rogers', 'arogers2j@goodreads.com', 'Female', '98.104.132.187');
+insert into {schema}.seed (first_name, last_name, email, gender, ip_address) values ('Emily', 'Dixon', 'edixon2k@mlb.com', 'Female', '39.190.75.57');
+insert into {schema}.seed (first_name, last_name, email, gender, ip_address) values ('Albert', 'Scott', 'ascott2l@tinypic.com', 'Male', '40.209.13.189');
+insert into {schema}.seed (first_name, last_name, email, gender, ip_address) values ('Barbara', 'Peterson', 'bpeterson2m@ow.ly', 'Female', '75.249.136.180');
+insert into {schema}.seed (first_name, last_name, email, gender, ip_address) values ('Adam', 'Greene', 'agreene2n@fastcompany.com', 'Male', '184.173.109.144');
+insert into {schema}.seed (first_name, last_name, email, gender, ip_address) values ('Earl', 'Sanders', 'esanders2o@hc360.com', 'Male', '247.34.90.117');
+insert into {schema}.seed (first_name, last_name, email, gender, ip_address) values ('Angela', 'Brooks', 'abrooks2p@mtv.com', 'Female', '10.63.249.126');
+insert into {schema}.seed (first_name, last_name, email, gender, ip_address) values ('Harold', 'Foster', 'hfoster2q@privacy.gov.au', 'Male', '139.214.40.244');
+insert into {schema}.seed (first_name, last_name, email, gender, ip_address) values ('Carl', 'Meyer', 'cmeyer2r@disqus.com', 'Male', '204.117.7.88');
--- a/test/integration/018_adapter_ddl_tests/test_adapter_ddl.py
+++ b/test/integration/018_adapter_ddl_tests/test_adapter_ddl.py
@@ -0,0 +1,23 @@
+from test.integration.base import DBTIntegrationTest, use_profile
+
+class TestAdapterDDL(DBTIntegrationTest):
+
+    def setUp(self):
+        DBTIntegrationTest.setUp(self)
+
+        self.run_sql_file("seed.sql")
+
+    @property
+    def schema(self):
+        return "adaper_ddl_018"
+
+    @property
+    def models(self):
+        return "models"
+
+    @use_profile('postgres')
+    def test_sort_and_dist_keys_are_nops_on_postgres(self):
+        results = self.run_dbt(['run'])
+        self.assertEqual(len(results), 1)
+
+        self.assertTablesEqual("seed","materialized")
--- a/test/integration/022_timezones_tests/models/timezones.sql
+++ b/test/integration/022_timezones_tests/models/timezones.sql
@@ -0,0 +1,10 @@
+
+{{
+    config(
+        materialized='table'
+    )
+}}
+
+select
+    '{{ run_started_at.astimezone(modules.pytz.timezone("America/New_York")) }}' as run_started_at_est,
+    '{{ run_started_at }}' as run_started_at_utc
--- a/test/integration/022_timezones_tests/test_timezones.py
+++ b/test/integration/022_timezones_tests/test_timezones.py
@@ -0,0 +1,52 @@
+from freezegun import freeze_time
+from test.integration.base import DBTIntegrationTest, use_profile
+
+
+class TestTimezones(DBTIntegrationTest):
+
+    @property
+    def schema(self):
+        return "timezones_022"
+
+    @property
+    def models(self):
+        return "models"
+
+    @property
+    def profile_config(self):
+        return {
+            'test': {
+                'outputs': {
+                    'dev': {
+                        'type': 'postgres',
+                        'threads': 1,
+                        'host': self.database_host,
+                        'port': 5432,
+                        'user': "root",
+                        'pass': "password",
+                        'dbname': 'dbt',
+                        'schema': self.unique_schema()
+                    },
+                },
+                'target': 'dev'
+            }
+        }
+
+    @property
+    def query(self):
+        return """
+            select
+              run_started_at_est,
+              run_started_at_utc
+            from {schema}.timezones
+        """.format(schema=self.unique_schema())
+
+    @freeze_time("2017-01-01 03:00:00", tz_offset=0)
+    @use_profile('postgres')
+    def test_postgres_run_started_at(self):
+        results = self.run_dbt(['run'])
+        self.assertEqual(len(results), 1)
+        result = self.run_sql(self.query, fetch='all')[0]
+        est, utc = result
+        self.assertEqual(utc, '2017-01-01 03:00:00+00:00')
+        self.assertEqual(est, '2016-12-31 22:00:00-05:00')
--- a/test/integration/037_external_reference_tests/models/my_model.sql
+++ b/test/integration/037_external_reference_tests/models/my_model.sql
@@ -0,0 +1,7 @@
+{{
+  config(
+    materialized = "view"
+  )
+}}
+
+select * from "{{ this.schema + 'z' }}"."external"
--- a/test/integration/037_external_reference_tests/standalone_models/my_model.sql
+++ b/test/integration/037_external_reference_tests/standalone_models/my_model.sql
@@ -0,0 +1,2 @@
+
+select 1 as id
--- a/test/integration/037_external_reference_tests/test_external_reference.py
+++ b/test/integration/037_external_reference_tests/test_external_reference.py
@@ -0,0 +1,78 @@
+from test.integration.base import DBTIntegrationTest, use_profile
+
+class TestExternalReference(DBTIntegrationTest):
+    @property
+    def schema(self):
+        return "external_reference_037"
+
+    @property
+    def models(self):
+        return "models"
+
+    def setUp(self):
+        super().setUp()
+        self.use_default_project()
+        self.external_schema = self.unique_schema()+'z'
+        self.run_sql(
+            'create schema "{}"'.format(self.external_schema)
+        )
+        self.run_sql(
+            'create table "{}"."external" (id integer)'
+            .format(self.external_schema)
+        )
+        self.run_sql(
+            'insert into "{}"."external" values (1), (2)'
+            .format(self.external_schema)
+        )
+
+    def tearDown(self):
+        # This has to happen before we drop the external schema, because
+        # otherwise postgres hangs forever.
+        self._drop_schemas()
+        with self.get_connection():
+            self._drop_schema_named(self.default_database, self.external_schema)
+        super().tearDown()
+
+    @use_profile('postgres')
+    def test__postgres__external_reference(self):
+        self.assertEqual(len(self.run_dbt()), 1)
+        # running it again should succeed
+        self.assertEqual(len(self.run_dbt()), 1)
+
+
+# The opposite of the test above -- check that external relations that
+# depend on a dbt model do not create issues with caching
+class TestExternalDependency(DBTIntegrationTest):
+    @property
+    def schema(self):
+        return "external_dependency_037"
+
+    @property
+    def models(self):
+        return "standalone_models"
+
+    def tearDown(self):
+        # This has to happen before we drop the external schema, because
+        # otherwise postgres hangs forever.
+        self._drop_schemas()
+        with self.get_connection():
+            self._drop_schema_named(self.default_database, self.external_schema)
+        super().tearDown()
+
+    @use_profile('postgres')
+    def test__postgres__external_reference(self):
+        self.assertEqual(len(self.run_dbt()), 1)
+
+        # create a view outside of the dbt schema that depends on this model
+        self.external_schema = self.unique_schema()+'zz'
+        self.run_sql(
+            'create schema "{}"'.format(self.external_schema)
+        )
+        self.run_sql(
+            'create view "{}"."external" as (select * from {}.my_model)'
+            .format(self.external_schema, self.unique_schema())
+        )
+
+        # running it again should succeed
+        self.assertEqual(len(self.run_dbt()), 1)
+
--- a/test/integration/043_custom_aliases_tests/macros-configs/macros.sql
+++ b/test/integration/043_custom_aliases_tests/macros-configs/macros.sql
@@ -0,0 +1,17 @@
+
+{#-- Verify that the config['alias'] key is present #}
+{% macro generate_alias_name(custom_alias_name, node) -%}
+    {%- if custom_alias_name is none -%}
+        {{ node.name }}
+    {%- else -%}
+        custom_{{ node.config['alias'] if 'alias' in node.config else '' | trim }}
+    {%- endif -%}
+{%- endmacro %}
+
+{% macro string_literal(s) -%}
+  {{ adapter.dispatch('string_literal', macro_namespace='test')(s) }}
+{%- endmacro %}
+
+{% macro default__string_literal(s) %}
+    '{{ s }}'::text
+{% endmacro %}
--- a/test/integration/043_custom_aliases_tests/macros/macros.sql
+++ b/test/integration/043_custom_aliases_tests/macros/macros.sql
@@ -0,0 +1,17 @@
+
+{% macro generate_alias_name(custom_alias_name, node) -%}
+    {%- if custom_alias_name is none -%}
+        {{ node.name }}
+    {%- else -%}
+        custom_{{ custom_alias_name | trim }}
+    {%- endif -%}
+{%- endmacro %}
+
+
+{% macro string_literal(s) -%}
+  {{ adapter.dispatch('string_literal', macro_namespace='test')(s) }}
+{%- endmacro %}
+
+{% macro default__string_literal(s) %}
+    '{{ s }}'::text
+{% endmacro %}
--- a/test/integration/043_custom_aliases_tests/models/model1.sql
+++ b/test/integration/043_custom_aliases_tests/models/model1.sql
@@ -0,0 +1,3 @@
+{{ config(materialized='table', alias='alias') }}
+
+select {{ string_literal(this.name) }} as model_name
--- a/test/integration/043_custom_aliases_tests/models/model2.sql
+++ b/test/integration/043_custom_aliases_tests/models/model2.sql
@@ -0,0 +1,3 @@
+{{ config(materialized='table') }}
+
+select {{ string_literal(this.name) }} as model_name
--- a/test/integration/043_custom_aliases_tests/models/schema.yml
+++ b/test/integration/043_custom_aliases_tests/models/schema.yml
@@ -0,0 +1,15 @@
+version: 2
+
+models:
+  - name: model1
+    columns:
+      - name: model_name
+        tests:
+          - accepted_values:
+             values: ['custom_alias']
+  - name: model2
+    columns:
+      - name: model_name
+        tests:
+          - accepted_values:
+             values: ['model2']
--- a/test/integration/043_custom_aliases_tests/test_custom_aliases.py
+++ b/test/integration/043_custom_aliases_tests/test_custom_aliases.py
@@ -0,0 +1,39 @@
+from test.integration.base import DBTIntegrationTest, use_profile
+
+
+class TestAliases(DBTIntegrationTest):
+    @property
+    def schema(self):
+        return "custom_aliases_043"
+
+    @property
+    def models(self):
+        return "models"
+
+    @property
+    def project_config(self):
+        return {
+            'config-version': 2,
+            "macro-paths": ['macros'],
+        }
+
+    @use_profile('postgres')
+    def test_postgres_customer_alias_name(self):
+        results = self.run_dbt(['run'])
+        self.assertEqual(len(results), 2)
+        self.run_dbt(['test'])
+
+
+class TestAliasesWithConfig(TestAliases):
+    @property
+    def project_config(self):
+        return {
+            'config-version': 2,
+            "macro-paths": ['macros-configs'],
+        }
+
+    @use_profile('postgres')
+    def test_postgres_customer_alias_name(self):
+        results = self.run_dbt(['run'])
+        self.assertEqual(len(results), 2)
+        self.run_dbt(['test'])
--- a/test/integration/055_ref_override_tests/macros/ref_override_macro.sql
+++ b/test/integration/055_ref_override_tests/macros/ref_override_macro.sql
@@ -0,0 +1,4 @@
+-- Macro to override ref and always return the same result
+{% macro ref(modelname) %}
+{% do return(builtins.ref(modelname).replace_path(identifier='seed_2')) %}
+{% endmacro %}
--- a/test/integration/055_ref_override_tests/models/ref_override.sql
+++ b/test/integration/055_ref_override_tests/models/ref_override.sql
@@ -0,0 +1,3 @@
+select
+    *
+from {{ ref('seed_1') }}
--- a/test/integration/055_ref_override_tests/seeds/seed_1.csv
+++ b/test/integration/055_ref_override_tests/seeds/seed_1.csv
@@ -0,0 +1,4 @@
+a,b
+1,2
+2,4
+3,6
--- a/test/integration/055_ref_override_tests/seeds/seed_2.csv
+++ b/test/integration/055_ref_override_tests/seeds/seed_2.csv
@@ -0,0 +1,4 @@
+a,b
+6,2
+12,4
+18,6
--- a/test/integration/055_ref_override_tests/test_ref_override.py
+++ b/test/integration/055_ref_override_tests/test_ref_override.py
@@ -0,0 +1,30 @@
+from test.integration.base import DBTIntegrationTest, use_profile
+
+
+class TestRefOverride(DBTIntegrationTest):
+    @property
+    def schema(self):
+        return "dbt_ref_override_055"
+
+    @property
+    def project_config(self):
+        return {
+            'config-version': 2,
+            'seed-paths': ['seeds'],
+            "macro-paths": ["macros"],
+            'seeds': {
+                'quote_columns': False,
+            },
+        }
+
+    @property
+    def models(self):
+        return "models"
+
+    @use_profile('postgres')
+    def test_postgres_ref_override(self):
+        self.run_dbt(['seed'])
+        self.run_dbt(['run'])
+        # We want it to equal seed_2 and not seed_1. If it's
+        # still pointing at seed_1 then the override hasn't worked.
+        self.assertTablesEqual('ref_override', 'seed_2')
--- a/test/integration/057_run_query_tests/macros/test_pg_array_queries.sql
+++ b/test/integration/057_run_query_tests/macros/test_pg_array_queries.sql
@@ -1,8 +1,4 @@
-import pytest

-from dbt.tests.util import run_dbt
-
-macros_sql = """
 {% macro test_array_results() %}

    {% set sql %}
@@ -18,16 +14,3 @@ macros_sql = """
    {% endif %}

 {% endmacro %}
-"""
-
-
-class TestTypes:
-    @pytest.fixture(scope="class")
-    def macros(self):
-        return {
-            "macros.sql": macros_sql,
-        }
-
-    def test_nested_types(self, project):
-        result = run_dbt(["run-operation", "test_array_results"])
-        assert result.success
--- a/test/integration/057_run_query_tests/test_pg_types.py
+++ b/test/integration/057_run_query_tests/test_pg_types.py
@@ -0,0 +1,25 @@
+
+from test.integration.base import DBTIntegrationTest, use_profile
+import json
+
+class TestPostgresTypes(DBTIntegrationTest):
+
+    @property
+    def schema(self):
+        return "pg_query_types_057"
+
+    @property
+    def models(self):
+        return "models"
+
+    @property
+    def project_config(self):
+        return {
+            'config-version': 2,
+            'macro-paths': ['macros'],
+        }
+
+    @use_profile('postgres')
+    def test__postgres_nested_types(self):
+        result = self.run_dbt(['run-operation', 'test_array_results'])
+        self.assertTrue(result.success)
--- a/test/integration/062_defer_state_tests/changed_models/ephemeral_model.sql
+++ b/test/integration/062_defer_state_tests/changed_models/ephemeral_model.sql
@@ -1,2 +0,0 @@
-{{ config(materialized='ephemeral') }}
-select * from {{ ref('view_model') }}
--- a/test/integration/062_defer_state_tests/changed_models/table_model.sql
+++ b/test/integration/062_defer_state_tests/changed_models/table_model.sql
@@ -1,5 +0,0 @@
-{{ config(materialized='table') }}
-select * from {{ ref('ephemeral_model') }}
-
-- establish a macro dependency to trigger state:modified.macros
-- depends on: {{ my_macro() }}
--- a/test/integration/062_defer_state_tests/changed_models/view_model.sql
+++ b/test/integration/062_defer_state_tests/changed_models/view_model.sql
@@ -1 +0,0 @@
-select * from no.such.table
--- a/test/integration/062_defer_state_tests/changed_models_bad/ephemeral_model.sql
+++ b/test/integration/062_defer_state_tests/changed_models_bad/ephemeral_model.sql
@@ -1,2 +0,0 @@
-{{ config(materialized='ephemeral') }}
-select * from no.such.table
--- a/test/integration/062_defer_state_tests/changed_models_bad/schema.yml
+++ b/test/integration/062_defer_state_tests/changed_models_bad/schema.yml
@@ -1,9 +0,0 @@
-version: 2
-models:
-  - name: view_model
-    columns:
-      - name: id
-        tests:
-          - unique
-          - not_null
-      - name: name
--- a/test/integration/062_defer_state_tests/changed_models_bad/table_model.sql
+++ b/test/integration/062_defer_state_tests/changed_models_bad/table_model.sql
@@ -1,5 +0,0 @@
-{{ config(materialized='table') }}
-select * from {{ ref('ephemeral_model') }}
-
-- establish a macro dependency to trigger state:modified.macros
-- depends on: {{ my_macro() }}
--- a/test/integration/062_defer_state_tests/changed_models_bad/view_model.sql
+++ b/test/integration/062_defer_state_tests/changed_models_bad/view_model.sql
@@ -1 +0,0 @@
-select * from no.such.table
--- a/test/integration/062_defer_state_tests/changed_models_missing/table_model.sql
+++ b/test/integration/062_defer_state_tests/changed_models_missing/table_model.sql
@@ -1,2 +0,0 @@
-{{ config(materialized='table') }}
-select 1 as fun
--- a/test/integration/062_defer_state_tests/macros/infinite_macros.sql
+++ b/test/integration/062_defer_state_tests/macros/infinite_macros.sql
@@ -1,13 +0,0 @@
-{# trigger infinite recursion if not handled #}
-
-{% macro my_infinitely_recursive_macro() %}
-  {{ return(adapter.dispatch('my_infinitely_recursive_macro')()) }}
-{% endmacro %}
-
-{% macro default__my_infinitely_recursive_macro() %}
-    {% if unmet_condition %}
-        {{ my_infinitely_recursive_macro() }}
-    {% else %}
-        {{ return('') }}
-    {% endif %}
-{% endmacro %}
--- a/test/integration/062_defer_state_tests/macros/macros.sql
+++ b/test/integration/062_defer_state_tests/macros/macros.sql
@@ -1,3 +0,0 @@
-{% macro my_macro() %}
-    {% do log('in a macro' ) %}
-{% endmacro %}
--- a/test/integration/062_defer_state_tests/models/ephemeral_model.sql
+++ b/test/integration/062_defer_state_tests/models/ephemeral_model.sql
@@ -1,2 +0,0 @@
-{{ config(materialized='ephemeral') }}
-select * from {{ ref('view_model') }}
--- a/test/integration/062_defer_state_tests/models/exposures.yml
+++ b/test/integration/062_defer_state_tests/models/exposures.yml
@@ -1,8 +0,0 @@
-version: 2
-exposures:
-  - name: my_exposure
-    type: application
-    depends_on:
-      - ref('view_model')
-    owner:
-      email: test@example.com
--- a/test/integration/062_defer_state_tests/models/schema.yml
+++ b/test/integration/062_defer_state_tests/models/schema.yml
@@ -1,10 +0,0 @@
-version: 2
-models:
-  - name: view_model
-    columns:
-      - name: id
-        tests:
-          - unique:
-              severity: error
-          - not_null
-      - name: name
--- a/test/integration/062_defer_state_tests/models/table_model.sql
+++ b/test/integration/062_defer_state_tests/models/table_model.sql
@@ -1,5 +0,0 @@
-{{ config(materialized='table') }}
-select * from {{ ref('ephemeral_model') }}
-
-- establish a macro dependency to trigger state:modified.macros
-- depends on: {{ my_macro() }}
--- a/test/integration/062_defer_state_tests/models/view_model.sql
+++ b/test/integration/062_defer_state_tests/models/view_model.sql
@@ -1,4 +0,0 @@
-select * from {{ ref('seed') }}
-
-- establish a macro dependency that trips infinite recursion if not handled
-- depends on: {{ my_infinitely_recursive_macro() }}
--- a/test/integration/062_defer_state_tests/previous_state/manifest.json
+++ b/test/integration/062_defer_state_tests/previous_state/manifest.json
@@ -1,6 +0,0 @@
-{
-    "metadata": {
-        "dbt_schema_version": "https://schemas.getdbt.com/dbt/manifest/v3.json",
-        "dbt_version": "0.21.1"
-    }
-}
--- a/test/integration/062_defer_state_tests/seeds/seed.csv
+++ b/test/integration/062_defer_state_tests/seeds/seed.csv
@@ -1,3 +0,0 @@
-id,name
-1,Alice
-2,Bob
--- a/test/integration/062_defer_state_tests/snapshots/my_snapshot.sql
+++ b/test/integration/062_defer_state_tests/snapshots/my_snapshot.sql
@@ -1,14 +0,0 @@
-{% snapshot my_cool_snapshot %}
-
-    {{
-        config(
-            target_database=database,
-            target_schema=schema,
-            unique_key='id',
-            strategy='check',
-            check_cols=['id'],
-        )
-    }}
-    select * from {{ ref('view_model') }}
-
-{% endsnapshot %}
--- a/test/integration/062_defer_state_tests/test_defer_state.py
+++ b/test/integration/062_defer_state_tests/test_defer_state.py
@@ -1,354 +0,0 @@
-from test.integration.base import DBTIntegrationTest, use_profile
-import copy
-import json
-import os
-import shutil
-
-import pytest
-import dbt.exceptions
-
-
-class TestDeferState(DBTIntegrationTest):
-    @property
-    def schema(self):
-        return "defer_state_062"
-
-    @property
-    def models(self):
-        return "models"
-
-    def setUp(self):
-        self.other_schema = None
-        super().setUp()
-        self._created_schemas.add(self.other_schema)
-
-    @property
-    def project_config(self):
-        return {
-            'config-version': 2,
-            'seeds': {
-                'test': {
-                    'quote_columns': False,
-                }
-            }
-        }
-
-    def get_profile(self, adapter_type):
-        if self.other_schema is None:
-            self.other_schema = self.unique_schema() + '_other'
-        profile = super().get_profile(adapter_type)
-        default_name = profile['test']['target']
-        profile['test']['outputs']['otherschema'] = copy.deepcopy(profile['test']['outputs'][default_name])
-        profile['test']['outputs']['otherschema']['schema'] = self.other_schema
-        return profile
-
-    def copy_state(self):
-        assert not os.path.exists('state')
-        os.makedirs('state')
-        shutil.copyfile('target/manifest.json', 'state/manifest.json')
-
-    def run_and_compile_defer(self):
-        results = self.run_dbt(['seed'])
-        assert len(results) == 1
-        assert not any(r.node.deferred for r in results)
-        results = self.run_dbt(['run'])
-        assert len(results) == 2
-        assert not any(r.node.deferred for r in results)
-        results = self.run_dbt(['test'])
-        assert len(results) == 2
-
-        # copy files
-        self.copy_state()
-
-        # defer test, it succeeds
-        results, success = self.run_dbt_and_check(['compile', '--state', 'state', '--defer'])
-        self.assertEqual(len(results.results), 6)
-        self.assertEqual(results.results[0].node.name, "seed")
-        self.assertTrue(success)        
-
-    def run_and_snapshot_defer(self):
-        results = self.run_dbt(['seed'])
-        assert len(results) == 1
-        assert not any(r.node.deferred for r in results)
-        results = self.run_dbt(['run'])
-        assert len(results) == 2
-        assert not any(r.node.deferred for r in results)
-        results = self.run_dbt(['test'])
-        assert len(results) == 2
-
-        # snapshot succeeds without --defer
-        results = self.run_dbt(['snapshot'])
-
-        # no state, snapshot fails
-        with pytest.raises(dbt.exceptions.DbtRuntimeError):
-            results = self.run_dbt(['snapshot', '--state', 'state', '--defer'])
-
-        # copy files
-        self.copy_state()
-
-        # defer test, it succeeds
-        results = self.run_dbt(['snapshot', '--state', 'state', '--defer'])
-
-        # favor_state test, it succeeds
-        results = self.run_dbt(['snapshot', '--state', 'state', '--defer', '--favor-state'])
-
-    def run_and_defer(self):
-        results = self.run_dbt(['seed'])
-        assert len(results) == 1
-        assert not any(r.node.deferred for r in results)
-        results = self.run_dbt(['run'])
-        assert len(results) == 2
-        assert not any(r.node.deferred for r in results)
-        results = self.run_dbt(['test'])
-        assert len(results) == 2
-
-        # copy files over from the happy times when we had a good target
-        self.copy_state()
-
-        # test tests first, because run will change things
-        # no state, wrong schema, failure.
-        self.run_dbt(['test', '--target', 'otherschema'], expect_pass=False)
-
-        # test generate docs
-        # no state, wrong schema, empty nodes 
-        catalog = self.run_dbt(['docs','generate','--target', 'otherschema'])
-        assert not catalog.nodes
-
-        # no state, run also fails
-        self.run_dbt(['run', '--target', 'otherschema'], expect_pass=False)
-
-        # defer test, it succeeds
-        results = self.run_dbt(['test', '-m', 'view_model+', '--state', 'state', '--defer', '--target', 'otherschema'])
-
-        # defer docs generate with state, catalog refers schema from the happy times
-        catalog = self.run_dbt(['docs','generate', '-m', 'view_model+', '--state', 'state', '--defer','--target', 'otherschema'])
-        assert self.other_schema not in catalog.nodes["seed.test.seed"].metadata.schema
-        assert self.unique_schema() in catalog.nodes["seed.test.seed"].metadata.schema
-
-        # with state it should work though
-        results = self.run_dbt(['run', '-m', 'view_model', '--state', 'state', '--defer', '--target', 'otherschema'])
-        assert self.other_schema not in results[0].node.compiled_code
-        assert self.unique_schema() in results[0].node.compiled_code
-
-        with open('target/manifest.json') as fp:
-            data = json.load(fp)
-        assert data['nodes']['seed.test.seed']['deferred']
-
-        assert len(results) == 1
-
-    def run_and_defer_favor_state(self):
-        results = self.run_dbt(['seed'])
-        assert len(results) == 1
-        assert not any(r.node.deferred for r in results)
-        results = self.run_dbt(['run'])
-        assert len(results) == 2
-        assert not any(r.node.deferred for r in results)
-        results = self.run_dbt(['test'])
-        assert len(results) == 2
-
-        # copy files over from the happy times when we had a good target
-        self.copy_state()
-
-        # test tests first, because run will change things
-        # no state, wrong schema, failure.
-        self.run_dbt(['test', '--target', 'otherschema'], expect_pass=False)
-
-        # no state, run also fails
-        self.run_dbt(['run', '--target', 'otherschema'], expect_pass=False)
-
-        # defer test, it succeeds
-        results = self.run_dbt(['test', '-m', 'view_model+', '--state', 'state', '--defer', '--favor-state', '--target', 'otherschema'])
-
-        # with state it should work though
-        results = self.run_dbt(['run', '-m', 'view_model', '--state', 'state', '--defer', '--favor-state', '--target', 'otherschema'])
-        assert self.other_schema not in results[0].node.compiled_code
-        assert self.unique_schema() in results[0].node.compiled_code
-
-        with open('target/manifest.json') as fp:
-            data = json.load(fp)
-        assert data['nodes']['seed.test.seed']['deferred']
-
-        assert len(results) == 1
-
-    def run_switchdirs_defer(self):
-        results = self.run_dbt(['seed'])
-        assert len(results) == 1
-        results = self.run_dbt(['run'])
-        assert len(results) == 2
-
-        # copy files over from the happy times when we had a good target
-        self.copy_state()
-
-        self.use_default_project({'model-paths': ['changed_models']})
-        # the sql here is just wrong, so it should fail
-        self.run_dbt(
-            ['run', '-m', 'view_model', '--state', 'state', '--defer', '--target', 'otherschema'],
-            expect_pass=False,
-        )
-        # but this should work since we just use the old happy model
-        self.run_dbt(
-            ['run', '-m', 'table_model', '--state', 'state', '--defer', '--target', 'otherschema'],
-            expect_pass=True,
-        )
-
-        self.use_default_project({'model-paths': ['changed_models_bad']})
-        # this should fail because the table model refs a broken ephemeral
-        # model, which it should see
-        self.run_dbt(
-            ['run', '-m', 'table_model', '--state', 'state', '--defer', '--target', 'otherschema'],
-            expect_pass=False,
-        )
-
-    def run_switchdirs_defer_favor_state(self):
-        results = self.run_dbt(['seed'])
-        assert len(results) == 1
-        results = self.run_dbt(['run'])
-        assert len(results) == 2
-
-        # copy files over from the happy times when we had a good target
-        self.copy_state()
-
-        self.use_default_project({'model-paths': ['changed_models']})
-        # the sql here is just wrong, so it should fail
-        self.run_dbt(
-            ['run', '-m', 'view_model', '--state', 'state', '--defer', '--favor-state', '--target', 'otherschema'],
-            expect_pass=False,
-        )
-        # but this should work since we just use the old happy model
-        self.run_dbt(
-            ['run', '-m', 'table_model', '--state', 'state', '--defer', '--favor-state', '--target', 'otherschema'],
-            expect_pass=True,
-        )
-
-        self.use_default_project({'model-paths': ['changed_models_bad']})
-        # this should fail because the table model refs a broken ephemeral
-        # model, which it should see
-        self.run_dbt(
-            ['run', '-m', 'table_model', '--state', 'state', '--defer', '--favor-state', '--target', 'otherschema'],
-            expect_pass=False,
-        )
-
-    def run_defer_iff_not_exists(self):
-        results = self.run_dbt(['seed', '--target', 'otherschema'])
-        assert len(results) == 1
-        results = self.run_dbt(['run', '--target', 'otherschema'])
-        assert len(results) == 2
-
-        # copy files over from the happy times when we had a good target
-        self.copy_state()
-        results = self.run_dbt(['seed'])
-        assert len(results) == 1
-        results = self.run_dbt(['run', '--state', 'state', '--defer'])
-        assert len(results) == 2
-
-        # because the seed now exists in our schema, we shouldn't defer it
-        assert self.other_schema not in results[0].node.compiled_code
-        assert self.unique_schema() in results[0].node.compiled_code
-
-    def run_defer_iff_not_exists_favor_state(self):
-        results = self.run_dbt(['seed'])
-        assert len(results) == 1
-        results = self.run_dbt(['run'])
-        assert len(results) == 2
-
-        # copy files over from the happy times when we had a good target
-        self.copy_state()
-        results = self.run_dbt(['seed'])
-        assert len(results) == 1
-        results = self.run_dbt(['run', '--state', 'state', '--defer', '--favor-state', '--target', 'otherschema'])
-        assert len(results) == 2
-
-        # because the seed exists in other schema, we should defer it
-        assert self.other_schema not in results[0].node.compiled_code
-        assert self.unique_schema() in results[0].node.compiled_code
-
-    def run_defer_deleted_upstream(self):
-        results = self.run_dbt(['seed'])
-        assert len(results) == 1
-        results = self.run_dbt(['run'])
-        assert len(results) == 2
-
-        # copy files over from the happy times when we had a good target
-        self.copy_state()
-
-        self.use_default_project({'model-paths': ['changed_models_missing']})
-        # ephemeral_model is now gone. previously this caused a
-        # keyerror (dbt#2875), now it should pass
-        self.run_dbt(
-            ['run', '-m', 'view_model', '--state', 'state', '--defer', '--target', 'otherschema'],
-            expect_pass=True,
-        )
-
-        # despite deferral, test should use models just created in our schema
-        results = self.run_dbt(['test', '--state', 'state', '--defer'])
-        assert self.other_schema not in results[0].node.compiled_code
-        assert self.unique_schema() in results[0].node.compiled_code
-
-    def run_defer_deleted_upstream_favor_state(self):
-        results = self.run_dbt(['seed'])
-        assert len(results) == 1
-        results = self.run_dbt(['run'])
-        assert len(results) == 2
-
-        # copy files over from the happy times when we had a good target
-        self.copy_state()
-
-        self.use_default_project({'model-paths': ['changed_models_missing']})
-
-        self.run_dbt(
-            ['run', '-m', 'view_model', '--state', 'state', '--defer', '--favor-state', '--target', 'otherschema'],
-            expect_pass=True,
-        )
-
-        # despite deferral, test should use models just created in our schema
-        results = self.run_dbt(['test', '--state', 'state', '--defer', '--favor-state'])
-        assert self.other_schema not in results[0].node.compiled_code
-        assert self.unique_schema() in results[0].node.compiled_code
-
-    @use_profile('postgres')
-    def test_postgres_state_changetarget(self):
-        self.run_and_defer()
-
-        # make sure these commands don't work with --defer
-        with pytest.raises(SystemExit):
-            self.run_dbt(['seed', '--defer'])
-
-    @use_profile('postgres')
-    def test_postgres_state_changetarget_favor_state(self):
-        self.run_and_defer_favor_state()
-
-        # make sure these commands don't work with --defer
-        with pytest.raises(SystemExit):
-            self.run_dbt(['seed', '--defer'])
-
-    @use_profile('postgres')
-    def test_postgres_state_changedir(self):
-        self.run_switchdirs_defer()
-
-    @use_profile('postgres')
-    def test_postgres_state_changedir_favor_state(self):
-        self.run_switchdirs_defer_favor_state()
-
-    @use_profile('postgres')
-    def test_postgres_state_defer_iffnotexists(self):
-        self.run_defer_iff_not_exists()
-
-    @use_profile('postgres')
-    def test_postgres_state_defer_iffnotexists_favor_state(self):
-        self.run_defer_iff_not_exists_favor_state()
-
-    @use_profile('postgres')
-    def test_postgres_state_defer_deleted_upstream(self):
-        self.run_defer_deleted_upstream()
-
-    @use_profile('postgres')
-    def test_postgres_state_defer_deleted_upstream_favor_state(self):
-        self.run_defer_deleted_upstream_favor_state()
-
-    @use_profile('postgres')
-    def test_postgres_state_snapshot_defer(self):
-        self.run_and_snapshot_defer()
-
-    @use_profile('postgres')
-    def test_postgres_state_compile_defer(self):
-        self.run_and_compile_defer()
--- a/test/integration/062_defer_state_tests/test_modified_state.py
+++ b/test/integration/062_defer_state_tests/test_modified_state.py
@@ -1,211 +0,0 @@
-from test.integration.base import DBTIntegrationTest, use_profile
-import os
-import random
-import shutil
-import string
-
-import pytest
-
-from dbt.exceptions import CompilationError, IncompatibleSchemaError
-
-
-class TestModifiedState(DBTIntegrationTest):
-    @property
-    def schema(self):
-        return "modified_state_062"
-
-    @property
-    def models(self):
-        return "models"
-
-    @property
-    def project_config(self):
-        return {
-            'config-version': 2,
-            'macro-paths': ['macros'],
-            'seeds': {
-                'test': {
-                    'quote_columns': True,
-                }
-            }
-        }
-
-    def _symlink_test_folders(self):
-        # dbt's normal symlink behavior breaks this test. Copy the files
-        # so we can freely modify them.
-        for entry in os.listdir(self.test_original_source_path):
-            src = os.path.join(self.test_original_source_path, entry)
-            tst = os.path.join(self.test_root_dir, entry)
-            if entry in {'models', 'seeds', 'macros', 'previous_state'}:
-                shutil.copytree(src, tst)
-            elif os.path.isdir(entry) or entry.endswith('.sql'):
-                os.symlink(src, tst)
-
-    def copy_state(self):
-        assert not os.path.exists('state')
-        os.makedirs('state')
-        shutil.copyfile('target/manifest.json', 'state/manifest.json')
-
-    def setUp(self):
-        super().setUp()
-        self.run_dbt(['seed'])
-        self.run_dbt(['run'])
-        self.copy_state()
-
-    @use_profile('postgres')
-    def test_postgres_changed_seed_contents_state(self):
-        results = self.run_dbt(['ls', '--resource-type', 'seed', '--select', 'state:modified', '--state', './state'], expect_pass=True)
-        assert len(results) == 0
-        with open('seeds/seed.csv') as fp:
-            fp.readline()
-            newline = fp.newlines
-        with open('seeds/seed.csv', 'a') as fp:
-            fp.write(f'3,carl{newline}')
-
-        results = self.run_dbt(['ls', '--resource-type', 'seed', '--select', 'state:modified', '--state', './state'])
-        assert len(results) == 1
-        assert results[0] == 'test.seed'
-
-        results = self.run_dbt(['ls', '--select', 'state:modified', '--state', './state'])
-        assert len(results) == 1
-        assert results[0] == 'test.seed'
-
-        results = self.run_dbt(['ls', '--select', 'state:modified+', '--state', './state'])
-        assert len(results) == 7
-        assert set(results) == {'test.seed', 'test.table_model', 'test.view_model', 'test.ephemeral_model', 'test.not_null_view_model_id', 'test.unique_view_model_id', 'exposure:test.my_exposure'}
-
-        shutil.rmtree('./state')
-        self.copy_state()
-
-        with open('seeds/seed.csv', 'a') as fp:
-            # assume each line is ~2 bytes + len(name)
-            target_size = 1*1024*1024
-            line_size = 64
-
-            num_lines = target_size // line_size
-
-            maxlines = num_lines + 4
-
-            for idx in range(4, maxlines):
-                value = ''.join(random.choices(string.ascii_letters, k=62))
-                fp.write(f'{idx},{value}{newline}')
-
-        # now if we run again, we should get a warning
-        results = self.run_dbt(['ls', '--resource-type', 'seed', '--select', 'state:modified', '--state', './state'])
-        assert len(results) == 1
-        assert results[0] == 'test.seed'
-
-        with pytest.raises(CompilationError) as exc:
-            self.run_dbt(['--warn-error', 'ls', '--resource-type', 'seed', '--select', 'state:modified', '--state', './state'])
-        assert '>1MB' in str(exc.value)
-
-        shutil.rmtree('./state')
-        self.copy_state()
-
-        # once it's in path mode, we don't mark it as modified if it changes
-        with open('seeds/seed.csv', 'a') as fp:
-            fp.write(f'{random},test{newline}')
-
-        results = self.run_dbt(['ls', '--resource-type', 'seed', '--select', 'state:modified', '--state', './state'], expect_pass=True)
-        assert len(results) == 0
-
-    @use_profile('postgres')
-    def test_postgres_changed_seed_config(self):
-        results = self.run_dbt(['ls', '--resource-type', 'seed', '--select', 'state:modified', '--state', './state'], expect_pass=True)
-        assert len(results) == 0
-
-        self.use_default_project({'seeds': {'test': {'quote_columns': False}}})
-
-        # quoting change -> seed changed
-        results = self.run_dbt(['ls', '--resource-type', 'seed', '--select', 'state:modified', '--state', './state'])
-        assert len(results) == 1
-        assert results[0] == 'test.seed'
-
-    @use_profile('postgres')
-    def test_postgres_unrendered_config_same(self):
-        results = self.run_dbt(['ls', '--resource-type', 'model', '--select', 'state:modified', '--state', './state'], expect_pass=True)
-        assert len(results) == 0
-
-        # although this is the default value, dbt will recognize it as a change
-        # for previously-unconfigured models, because it's been explicitly set
-        self.use_default_project({'models': {'test': {'materialized': 'view'}}})
-        results = self.run_dbt(['ls', '--resource-type', 'model', '--select', 'state:modified', '--state', './state'])
-        assert len(results) == 1
-        assert results[0] == 'test.view_model'
-
-    @use_profile('postgres')
-    def test_postgres_changed_model_contents(self):
-        results = self.run_dbt(['run', '--models', 'state:modified', '--state', './state'])
-        assert len(results) == 0
-
-        with open('models/table_model.sql') as fp:
-            fp.readline()
-            newline = fp.newlines
-
-        with open('models/table_model.sql', 'w') as fp:
-            fp.write("{{ config(materialized='table') }}")
-            fp.write(newline)
-            fp.write("select * from {{ ref('seed') }}")
-            fp.write(newline)
-
-        results = self.run_dbt(['run', '--models', 'state:modified', '--state', './state'])
-        assert len(results) == 1
-        assert results[0].node.name == 'table_model'
-
-    @use_profile('postgres')
-    def test_postgres_new_macro(self):
-        with open('macros/macros.sql') as fp:
-            fp.readline()
-            newline = fp.newlines
-
-        new_macro = '{% macro my_other_macro() %}{% endmacro %}' + newline
-
-        # add a new macro to a new file
-        with open('macros/second_macro.sql', 'w') as fp:
-            fp.write(new_macro)
-
-        results, stdout = self.run_dbt_and_capture(['run', '--models', 'state:modified', '--state', './state'])
-        assert len(results) == 0
-
-        os.remove('macros/second_macro.sql')
-        # add a new macro to the existing file
-        with open('macros/macros.sql', 'a') as fp:
-            fp.write(new_macro)
-
-        results, stdout = self.run_dbt_and_capture(['run', '--models', 'state:modified', '--state', './state'])
-        assert len(results) == 0
-
-    @use_profile('postgres')
-    def test_postgres_changed_macro_contents(self):
-        with open('macros/macros.sql') as fp:
-            fp.readline()
-            newline = fp.newlines
-
-        # modify an existing macro
-        with open('macros/macros.sql', 'w') as fp:
-            fp.write("{% macro my_macro() %}")
-            fp.write(newline)
-            fp.write("    {% do log('in a macro', info=True) %}")
-            fp.write(newline)
-            fp.write('{% endmacro %}')
-            fp.write(newline)
-
-        # table_model calls this macro
-        results, stdout = self.run_dbt_and_capture(['run', '--models', 'state:modified', '--state', './state'])
-        assert len(results) == 1
-
-    @use_profile('postgres')
-    def test_postgres_changed_exposure(self):
-        with open('models/exposures.yml', 'a') as fp:
-            fp.write('      name: John Doe\n')
-
-        results, stdout = self.run_dbt_and_capture(['run', '--models', '+state:modified', '--state', './state'])
-        assert len(results) == 1
-        assert results[0].node.name == 'view_model'
-
-    @use_profile('postgres')
-    def test_postgres_previous_version_manifest(self):
-        # This tests that a different schema version in the file throws an error
-        with self.assertRaises(IncompatibleSchemaError) as exc:
-            results = self.run_dbt(['ls', '-s',  'state:modified',  '--state',  './previous_state'])
-            self.assertEqual(exc.CODE, 10014)
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
github-actions[bot]	a2e7249c44	Bumping version to 1.4.0 and generate CHANGELOG (#6727 ) Co-authored-by: Github Build Bot <buildbot@fishtownanalytics.com>	2023-01-25 10:17:36 -05:00
github-actions[bot]	9700ff1866	CT 1886 include adapter_response in NodeFinished log message (#6709 ) (#6714 ) * Include adapter_response in run_result in NodeFinished log event * Changie (cherry picked from commit `e2ccf011d9`) Co-authored-by: Gerda Shank <gerda@dbtlabs.com>	2023-01-24 15:38:51 -05:00
colin-rogers-dbt	e61a39f27f	mv `on_schema_change` tests -> "adapter zone" (#6618 ) (#6686 ) * mv `on_schema_change` tests -> "adapter zone" (#6618) * Mv incremental on_schema_change tests to 'adapter zone' * Use type_string() * Cleanup * mv `on_schema_change` tests -> "adapter zone" (#6618) * Mv incremental on_schema_change tests to 'adapter zone' * Use type_string() * Cleanup Co-authored-by: Jeremy Cohen <jeremy@dbtlabs.com>	2023-01-20 12:26:32 -08:00
github-actions[bot]	d934e713db	Bumping version to 1.4.0rc2 and generate CHANGELOG (#6661 ) Co-authored-by: Github Build Bot <buildbot@fishtownanalytics.com>	2023-01-19 12:13:06 -05:00
github-actions[bot]	ef9bb925d3	add backwards compatibility and default argument for `incremental_predicates` (#6628 ) (#6660 ) * add backwards compatibility and default argument * changie <3 * Update .changes/unreleased/Fixes-20230117-101342.yaml Co-authored-by: Jeremy Cohen <jeremy@dbtlabs.com> (cherry picked from commit `f841a7ca76`) Co-authored-by: dave-connors-3 <73915542+dave-connors-3@users.noreply.github.com>	2023-01-19 10:24:49 -05:00
github-actions[bot]	f73359b87c	[Backport 1.4.latest] convert 062_defer_state_tests (#6657 ) * convert 062_defer_state_tests (#6616) * Fix --favor-state flag * Convert 062_defer_state_tests * Revert "Fix --favor-state flag" This reverts commit ccbdcbad98b26822629364e6fdbd2780db0c20d3. * Reformat * Revert "Revert "Fix --favor-state flag"" This reverts commit `fa9d2a09d6`. (cherry picked from commit `07a004b301`) * Add changelog entry Co-authored-by: Jeremy Cohen <jeremy@dbtlabs.com>	2023-01-19 13:27:23 +01:00
Emily Rockman	b4706c4dec	finish message rename in types.proto (#6594 ) (#6596 ) * finish message rename in types.proto * add new parameter	2023-01-13 10:20:34 -06:00
github-actions[bot]	b46d35c13f	Call `update_event_status` earlier + rename an event (#6572 ) (#6591 ) * Rename HookFinished -> FinishedRunningStats * Move update_event_status earlier when node finishes * Add changelog entry * Add update_event_status for skip * Update changelog entry (cherry picked from commit `86e8722cd8`) Co-authored-by: Jeremy Cohen <jeremy@dbtlabs.com>	2023-01-13 11:53:14 +01:00
github-actions[bot]	eba90863ed	Bumping version to 1.4.0rc1 and generate CHANGELOG (#6569 ) Co-authored-by: Github Build Bot <buildbot@fishtownanalytics.com>	2023-01-10 22:04:55 -05:00