pax_global_header 0000666 0000000 0000000 00000000064 14314555116 0014517 g ustar 00root root 0000000 0000000 52 comment=867ee0cca56a62f111942e51676663c8ae1ce77f
atlas-0.7.2/ 0000775 0000000 0000000 00000000000 14314555116 0012631 5 ustar 00root root 0000000 0000000 atlas-0.7.2/.github/ 0000775 0000000 0000000 00000000000 14314555116 0014171 5 ustar 00root root 0000000 0000000 atlas-0.7.2/.github/workflows/ 0000775 0000000 0000000 00000000000 14314555116 0016226 5 ustar 00root root 0000000 0000000 atlas-0.7.2/.github/workflows/build-docker.yaml 0000664 0000000 0000000 00000001735 14314555116 0021464 0 ustar 00root root 0000000 0000000 name: Build Docker
on:
pull_request:
push:
branches:
- master
env:
CRDB_VERSIONS: v21.2.11 v22.1.0
jobs:
build-services:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v2.4.0
- uses: actions/setup-go@v2
with:
go-version: '1.18'
- name: Log in to registry
run: echo "${{ secrets.GITHUB_TOKEN }}" | docker login ghcr.io -u $ --password-stdin
- name: "build cockroach image"
run: |
VER="${{ env.CRDB_VERSIONS }}"
for i in $VER
do
:
if ! docker manifest inspect ghcr.io/ariga/cockroachdb-single-node:$i; then
go run internal/ci/cockroach/main.go $i > internal/ci/cockroach/Dockerfile
docker build -t ghcr.io/ariga/cockroachdb-single-node:$i internal/ci/cockroach/
docker push ghcr.io/ariga/cockroachdb-single-node:$i
else
echo image already exists
fi
done atlas-0.7.2/.github/workflows/ci-website.yaml 0000664 0000000 0000000 00000001273 14314555116 0021150 0 ustar 00root root 0000000 0000000 name: Docsite CI
on:
push:
branches-ignore:
- master
jobs:
docsite_ci:
name: verify build doesn't crash
runs-on: ubuntu-latest
defaults:
run:
working-directory: ./doc/website
steps:
- uses: actions/checkout@v2
- uses: actions/setup-node@v2.1.5
with:
node-version: 16
- name: Cache dependecies
uses: actions/cache@v2.1.6
with:
path: ~/.npm
key: ${{ runner.os }}-node-${{ hashFiles('**/package-lock.json') }}
restore-keys: |
${{ runner.os }}-node-
- name: Install Dependencies
run: npm install
- name: Build website
run: npm run build
atlas-0.7.2/.github/workflows/ci.yml 0000664 0000000 0000000 00000040202 14314555116 0017342 0 ustar 00root root 0000000 0000000 # # # # # # # # # # # # # # # #
# CODE GENERATED - DO NOT EDIT
# # # # # # # # # # # # # # # #
name: Continuous Integration
on:
pull_request:
paths-ignore:
- 'doc/**'
push:
branches:
- master
paths-ignore:
- 'doc/**'
jobs:
lint:
runs-on: ubuntu-latest
steps:
- uses: actions/setup-go@v2
with:
go-version: 1.18
- uses: actions/checkout@v2
- name: Run linters
uses: golangci/golangci-lint-action@v3
with:
args: --verbose
generate-cmp:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v2.4.0
- uses: actions/setup-go@v2
with:
go-version: '1.19'
- uses: actions/cache@v2.1.5
with:
path: ~/go/pkg/mod
key: ${{ runner.os }}-go-${{ hashFiles('**/go.sum') }}
restore-keys: |
${{ runner.os }}-go-
- name: run "go generate ./..."
run: go generate ./...
- name: go generate cmd/atlas
working-directory: cmd/atlas
run: go generate ./...
- name: Verify generated files are checked in properly
run: |
status=$(git status --porcelain | grep -v "go.\(sum\|mod\)" | cat)
if [ -n "$status" ]; then
echo "you need to run 'go generate ./...' and commit the changes"
echo "$status"
exit 1
fi
unit:
runs-on: ubuntu-latest
strategy:
matrix:
go: [ '1.18', '1.19' ]
steps:
- uses: actions/checkout@v2
- uses: actions/setup-go@v2
with:
go-version: ${{ matrix.go }}
- uses: actions/cache@v2.1.5
with:
path: ~/go/pkg/mod
key: ${{ runner.os }}-go-${{ hashFiles('**/go.sum') }}
restore-keys: |
${{ runner.os }}-go-
- name: Run sql tests
run: go test -race ./...
working-directory: sql
- name: Run schemahcl tests
run: go test -race ./...
working-directory: schemahcl
cli:
runs-on: ubuntu-latest
strategy:
matrix:
go: [ '1.19' ]
steps:
- uses: actions/checkout@v2
- uses: actions/setup-go@v2
with:
go-version: ${{ matrix.go }}
- uses: actions/cache@v2.1.5
with:
path: ~/go/pkg/mod
key: ${{ runner.os }}-go-${{ hashFiles('**/go.sum') }}
restore-keys: |
${{ runner.os }}-go-
- name: Run cli tests
run: go test -race ./...
working-directory: cmd/atlas
integration:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v2.3.4
- uses: actions/setup-go@v2
with:
go-version: 1.19
- uses: actions/cache@v2.1.6
with:
path: ~/go/pkg/mod
key: ${{ runner.os }}-go-${{ hashFiles('**/go.sum') }}
restore-keys: |
${{ runner.os }}-go-
- name: Run integration tests for HCL
working-directory: internal/integration/hclsqlspec
run: go test -race -count=2 -v ./...
revisions:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v2.3.4
with:
fetch-depth: 0
- uses: actions/setup-go@v2
with:
go-version: 1.19
- uses: actions/cache@v2.1.6
with:
path: ~/go/pkg/mod
key: ${{ runner.os }}-go-${{ hashFiles('**/go.sum') }}
restore-keys: |
${{ runner.os }}-go-
- name: Checkout origin/master
run: git checkout origin/master
- name: Create revisions from master
run: go run main.go migrate apply --dir file://internal/cmdapi/testdata/sqlite --url sqlite://db?_fk=1
working-directory: cmd/atlas
- name: Checkout previous HEAD
run: git checkout -
- name: Migrate revisions table to HEAD
run: go run main.go migrate apply --dir file://internal/cmdapi/testdata/sqlite --url sqlite://db?_fk=1
working-directory: cmd/atlas
integration-mysql56:
runs-on: ubuntu-latest
services:
mysql56:
image: mysql:5.6.35
env:
MYSQL_DATABASE: test
MYSQL_ROOT_PASSWORD: pass
ports:
- 3306:3306
options: >-
--health-cmd "mysqladmin ping -ppass"
--health-interval 10s
--health-start-period 10s
--health-timeout 5s
--health-retries 10
steps:
- uses: actions/checkout@v2.3.4
- uses: actions/setup-go@v2
with:
go-version: 1.19
- uses: actions/cache@v2.1.6
with:
path: ~/go/pkg/mod
key: ${{ runner.os }}-go-${{ hashFiles('**/go.sum') }}
restore-keys: |
${{ runner.os }}-go-
- name: Run integration tests for mysql56
working-directory: internal/integration
run: go test -race -count=2 -v -run="MySQL" -version="mysql56" ./...
integration-mysql57:
runs-on: ubuntu-latest
services:
mysql57:
image: mysql:5.7.26
env:
MYSQL_DATABASE: test
MYSQL_ROOT_PASSWORD: pass
ports:
- 3307:3306
options: >-
--health-cmd "mysqladmin ping -ppass"
--health-interval 10s
--health-start-period 10s
--health-timeout 5s
--health-retries 10
steps:
- uses: actions/checkout@v2.3.4
- uses: actions/setup-go@v2
with:
go-version: 1.19
- uses: actions/cache@v2.1.6
with:
path: ~/go/pkg/mod
key: ${{ runner.os }}-go-${{ hashFiles('**/go.sum') }}
restore-keys: |
${{ runner.os }}-go-
- name: Run integration tests for mysql57
working-directory: internal/integration
run: go test -race -count=2 -v -run="MySQL" -version="mysql57" ./...
integration-mysql8:
runs-on: ubuntu-latest
services:
mysql8:
image: mysql:8
env:
MYSQL_DATABASE: test
MYSQL_ROOT_PASSWORD: pass
ports:
- 3308:3306
options: >-
--health-cmd "mysqladmin ping -ppass"
--health-interval 10s
--health-start-period 10s
--health-timeout 5s
--health-retries 10
steps:
- uses: actions/checkout@v2.3.4
- uses: actions/setup-go@v2
with:
go-version: 1.19
- uses: actions/cache@v2.1.6
with:
path: ~/go/pkg/mod
key: ${{ runner.os }}-go-${{ hashFiles('**/go.sum') }}
restore-keys: |
${{ runner.os }}-go-
- name: Run integration tests for mysql8
working-directory: internal/integration
run: go test -race -count=2 -v -run="MySQL" -version="mysql8" ./...
integration-maria107:
runs-on: ubuntu-latest
services:
maria107:
image: mariadb:10.7
env:
MYSQL_DATABASE: test
MYSQL_ROOT_PASSWORD: pass
ports:
- 4306:3306
options: >-
--health-cmd "mysqladmin ping -ppass"
--health-interval 10s
--health-start-period 10s
--health-timeout 5s
--health-retries 10
steps:
- uses: actions/checkout@v2.3.4
- uses: actions/setup-go@v2
with:
go-version: 1.19
- uses: actions/cache@v2.1.6
with:
path: ~/go/pkg/mod
key: ${{ runner.os }}-go-${{ hashFiles('**/go.sum') }}
restore-keys: |
${{ runner.os }}-go-
- name: Run integration tests for maria107
working-directory: internal/integration
run: go test -race -count=2 -v -run="MySQL" -version="maria107" ./...
integration-maria102:
runs-on: ubuntu-latest
services:
maria102:
image: mariadb:10.2.32
env:
MYSQL_DATABASE: test
MYSQL_ROOT_PASSWORD: pass
ports:
- 4307:3306
options: >-
--health-cmd "mysqladmin ping -ppass"
--health-interval 10s
--health-start-period 10s
--health-timeout 5s
--health-retries 10
steps:
- uses: actions/checkout@v2.3.4
- uses: actions/setup-go@v2
with:
go-version: 1.19
- uses: actions/cache@v2.1.6
with:
path: ~/go/pkg/mod
key: ${{ runner.os }}-go-${{ hashFiles('**/go.sum') }}
restore-keys: |
${{ runner.os }}-go-
- name: Run integration tests for maria102
working-directory: internal/integration
run: go test -race -count=2 -v -run="MySQL" -version="maria102" ./...
integration-maria103:
runs-on: ubuntu-latest
services:
maria103:
image: mariadb:10.3.13
env:
MYSQL_DATABASE: test
MYSQL_ROOT_PASSWORD: pass
ports:
- 4308:3306
options: >-
--health-cmd "mysqladmin ping -ppass"
--health-interval 10s
--health-start-period 10s
--health-timeout 5s
--health-retries 10
steps:
- uses: actions/checkout@v2.3.4
- uses: actions/setup-go@v2
with:
go-version: 1.19
- uses: actions/cache@v2.1.6
with:
path: ~/go/pkg/mod
key: ${{ runner.os }}-go-${{ hashFiles('**/go.sum') }}
restore-keys: |
${{ runner.os }}-go-
- name: Run integration tests for maria103
working-directory: internal/integration
run: go test -race -count=2 -v -run="MySQL" -version="maria103" ./...
integration-postgres10:
runs-on: ubuntu-latest
services:
postgres10:
image: postgres:10
env:
POSTGRES_DB: test
POSTGRES_PASSWORD: pass
ports:
- 5430:5432
options: >-
--health-cmd pg_isready
--health-interval 10s
--health-timeout 5s
--health-retries 5
steps:
- uses: actions/checkout@v2.3.4
- uses: actions/setup-go@v2
with:
go-version: 1.19
- uses: actions/cache@v2.1.6
with:
path: ~/go/pkg/mod
key: ${{ runner.os }}-go-${{ hashFiles('**/go.sum') }}
restore-keys: |
${{ runner.os }}-go-
- name: Run integration tests for postgres10
working-directory: internal/integration
run: go test -race -count=2 -v -run="Postgres" -version="postgres10" ./...
integration-postgres11:
runs-on: ubuntu-latest
services:
postgres11:
image: postgres:11
env:
POSTGRES_DB: test
POSTGRES_PASSWORD: pass
ports:
- 5431:5432
options: >-
--health-cmd pg_isready
--health-interval 10s
--health-timeout 5s
--health-retries 5
steps:
- uses: actions/checkout@v2.3.4
- uses: actions/setup-go@v2
with:
go-version: 1.19
- uses: actions/cache@v2.1.6
with:
path: ~/go/pkg/mod
key: ${{ runner.os }}-go-${{ hashFiles('**/go.sum') }}
restore-keys: |
${{ runner.os }}-go-
- name: Run integration tests for postgres11
working-directory: internal/integration
run: go test -race -count=2 -v -run="Postgres" -version="postgres11" ./...
integration-postgres12:
runs-on: ubuntu-latest
services:
postgres12:
image: postgres:12.3
env:
POSTGRES_DB: test
POSTGRES_PASSWORD: pass
ports:
- 5432:5432
options: >-
--health-cmd pg_isready
--health-interval 10s
--health-timeout 5s
--health-retries 5
steps:
- uses: actions/checkout@v2.3.4
- uses: actions/setup-go@v2
with:
go-version: 1.19
- uses: actions/cache@v2.1.6
with:
path: ~/go/pkg/mod
key: ${{ runner.os }}-go-${{ hashFiles('**/go.sum') }}
restore-keys: |
${{ runner.os }}-go-
- name: Run integration tests for postgres12
working-directory: internal/integration
run: go test -race -count=2 -v -run="Postgres" -version="postgres12" ./...
integration-postgres13:
runs-on: ubuntu-latest
services:
postgres13:
image: postgres:13.1
env:
POSTGRES_DB: test
POSTGRES_PASSWORD: pass
ports:
- 5433:5432
options: >-
--health-cmd pg_isready
--health-interval 10s
--health-timeout 5s
--health-retries 5
steps:
- uses: actions/checkout@v2.3.4
- uses: actions/setup-go@v2
with:
go-version: 1.19
- uses: actions/cache@v2.1.6
with:
path: ~/go/pkg/mod
key: ${{ runner.os }}-go-${{ hashFiles('**/go.sum') }}
restore-keys: |
${{ runner.os }}-go-
- name: Run integration tests for postgres13
working-directory: internal/integration
run: go test -race -count=2 -v -run="Postgres" -version="postgres13" ./...
integration-postgres14:
runs-on: ubuntu-latest
services:
postgres14:
image: postgres:14
env:
POSTGRES_DB: test
POSTGRES_PASSWORD: pass
ports:
- 5434:5432
options: >-
--health-cmd pg_isready
--health-interval 10s
--health-timeout 5s
--health-retries 5
steps:
- uses: actions/checkout@v2.3.4
- uses: actions/setup-go@v2
with:
go-version: 1.19
- uses: actions/cache@v2.1.6
with:
path: ~/go/pkg/mod
key: ${{ runner.os }}-go-${{ hashFiles('**/go.sum') }}
restore-keys: |
${{ runner.os }}-go-
- name: Run integration tests for postgres14
working-directory: internal/integration
run: go test -race -count=2 -v -run="Postgres" -version="postgres14" ./...
integration-tidb5:
runs-on: ubuntu-latest
services:
tidb5:
image: pingcap/tidb:v5.4.0
ports:
- 4309:4000
steps:
- uses: actions/checkout@v2.3.4
- uses: actions/setup-go@v2
with:
go-version: 1.19
- uses: actions/cache@v2.1.6
with:
path: ~/go/pkg/mod
key: ${{ runner.os }}-go-${{ hashFiles('**/go.sum') }}
restore-keys: |
${{ runner.os }}-go-
- name: Run integration tests for tidb5
working-directory: internal/integration
run: go test -race -count=2 -v -run="TiDB" -version="tidb5" ./...
integration-tidb6:
runs-on: ubuntu-latest
services:
tidb6:
image: pingcap/tidb:v6.0.0
ports:
- 4310:4000
steps:
- uses: actions/checkout@v2.3.4
- uses: actions/setup-go@v2
with:
go-version: 1.19
- uses: actions/cache@v2.1.6
with:
path: ~/go/pkg/mod
key: ${{ runner.os }}-go-${{ hashFiles('**/go.sum') }}
restore-keys: |
${{ runner.os }}-go-
- name: Run integration tests for tidb6
working-directory: internal/integration
run: go test -race -count=2 -v -run="TiDB" -version="tidb6" ./...
integration-sqlite:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v2.3.4
- uses: actions/setup-go@v2
with:
go-version: 1.19
- uses: actions/cache@v2.1.6
with:
path: ~/go/pkg/mod
key: ${{ runner.os }}-go-${{ hashFiles('**/go.sum') }}
restore-keys: |
${{ runner.os }}-go-
- name: Run integration tests for sqlite
working-directory: internal/integration
run: go test -race -count=2 -v -run="SQLite.*" -version="sqlite" ./...
integration-cockroach:
runs-on: ubuntu-latest
services:
cockroach:
image: ghcr.io/ariga/cockroachdb-single-node:v21.2.11
ports:
- 26257:26257
steps:
- uses: actions/checkout@v2.3.4
- uses: actions/setup-go@v2
with:
go-version: 1.19
- uses: actions/cache@v2.1.6
with:
path: ~/go/pkg/mod
key: ${{ runner.os }}-go-${{ hashFiles('**/go.sum') }}
restore-keys: |
${{ runner.os }}-go-
- name: Run integration tests for cockroach
working-directory: internal/integration
run: go test -race -count=2 -v -run="Cockroach" -version="cockroach" ./...
atlas-0.7.2/.github/workflows/website.yaml 0000664 0000000 0000000 00000002131 14314555116 0020551 0 ustar 00root root 0000000 0000000 name: Continuous Deployment
on:
push:
branches:
- master
paths:
- 'doc/**'
jobs:
docs:
name: deploy atlasgo.io
runs-on: ubuntu-latest
defaults:
run:
working-directory: ./doc/website
steps:
- uses: actions/checkout@v2
- uses: actions/setup-node@v2.1.5
with:
node-version: 16
- name: Cache dependecies
uses: actions/cache@v2.1.6
with:
path: ~/.npm
key: ${{ runner.os }}-node-${{ hashFiles('**/package-lock.json') }}
restore-keys: |
${{ runner.os }}-node-
- name: Install Dependencies
run: npm install
- name: Build website
run: npm run build
- name: Configure AWS credentials
uses: aws-actions/configure-aws-credentials@v1
with:
aws-access-key-id: ${{ secrets.AWS_ACCESS_KEY_ID }}
aws-secret-access-key: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
aws-region: us-east-1
- name: Deploy Website
run: npm run upload
- name: Invalidate Cache
run: npm run invalidate-cdn
atlas-0.7.2/.golangci.yml 0000664 0000000 0000000 00000001011 14314555116 0015206 0 ustar 00root root 0000000 0000000 run:
timeout: 3m
issues:
include:
- EXC0012
exclude-rules:
- path: _test\.go
linters:
- gosec
- path: sql/migrate/dir.go
linters:
- gosec
linters-settings:
goheader:
template: |-
Copyright 2021-present The Atlas Authors. All rights reserved.
This source code is licensed under the Apache 2.0 license found
in the LICENSE file in the root directory of this source tree.
linters:
disable-all: true
enable:
- gosec
- revive
- goheader
atlas-0.7.2/LICENSE 0000664 0000000 0000000 00000026135 14314555116 0013645 0 ustar 00root root 0000000 0000000
Apache License
Version 2.0, January 2004
http://www.apache.org/licenses/
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
1. Definitions.
"License" shall mean the terms and conditions for use, reproduction,
and distribution as defined by Sections 1 through 9 of this document.
"Licensor" shall mean the copyright owner or entity authorized by
the copyright owner that is granting the License.
"Legal Entity" shall mean the union of the acting entity and all
other entities that control, are controlled by, or are under common
control with that entity. For the purposes of this definition,
"control" means (i) the power, direct or indirect, to cause the
direction or management of such entity, whether by contract or
otherwise, or (ii) ownership of fifty percent (50%) or more of the
outstanding shares, or (iii) beneficial ownership of such entity.
"You" (or "Your") shall mean an individual or Legal Entity
exercising permissions granted by this License.
"Source" form shall mean the preferred form for making modifications,
including but not limited to software source code, documentation
source, and configuration files.
"Object" form shall mean any form resulting from mechanical
transformation or translation of a Source form, including but
not limited to compiled object code, generated documentation,
and conversions to other media types.
"Work" shall mean the work of authorship, whether in Source or
Object form, made available under the License, as indicated by a
copyright notice that is included in or attached to the work
(an example is provided in the Appendix below).
"Derivative Works" shall mean any work, whether in Source or Object
form, that is based on (or derived from) the Work and for which the
editorial revisions, annotations, elaborations, or other modifications
represent, as a whole, an original work of authorship. For the purposes
of this License, Derivative Works shall not include works that remain
separable from, or merely link (or bind by name) to the interfaces of,
the Work and Derivative Works thereof.
"Contribution" shall mean any work of authorship, including
the original version of the Work and any modifications or additions
to that Work or Derivative Works thereof, that is intentionally
submitted to Licensor for inclusion in the Work by the copyright owner
or by an individual or Legal Entity authorized to submit on behalf of
the copyright owner. For the purposes of this definition, "submitted"
means any form of electronic, verbal, or written communication sent
to the Licensor or its representatives, including but not limited to
communication on electronic mailing lists, source code control systems,
and issue tracking systems that are managed by, or on behalf of, the
Licensor for the purpose of discussing and improving the Work, but
excluding communication that is conspicuously marked or otherwise
designated in writing by the copyright owner as "Not a Contribution."
"Contributor" shall mean Licensor and any individual or Legal Entity
on behalf of whom a Contribution has been received by Licensor and
subsequently incorporated within the Work.
2. Grant of Copyright License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
copyright license to reproduce, prepare Derivative Works of,
publicly display, publicly perform, sublicense, and distribute the
Work and such Derivative Works in Source or Object form.
3. Grant of Patent License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
(except as stated in this section) patent license to make, have made,
use, offer to sell, sell, import, and otherwise transfer the Work,
where such license applies only to those patent claims licensable
by such Contributor that are necessarily infringed by their
Contribution(s) alone or by combination of their Contribution(s)
with the Work to which such Contribution(s) was submitted. If You
institute patent litigation against any entity (including a
cross-claim or counterclaim in a lawsuit) alleging that the Work
or a Contribution incorporated within the Work constitutes direct
or contributory patent infringement, then any patent licenses
granted to You under this License for that Work shall terminate
as of the date such litigation is filed.
4. Redistribution. You may reproduce and distribute copies of the
Work or Derivative Works thereof in any medium, with or without
modifications, and in Source or Object form, provided that You
meet the following conditions:
(a) You must give any other recipients of the Work or
Derivative Works a copy of this License; and
(b) You must cause any modified files to carry prominent notices
stating that You changed the files; and
(c) You must retain, in the Source form of any Derivative Works
that You distribute, all copyright, patent, trademark, and
attribution notices from the Source form of the Work,
excluding those notices that do not pertain to any part of
the Derivative Works; and
(d) If the Work includes a "NOTICE" text file as part of its
distribution, then any Derivative Works that You distribute must
include a readable copy of the attribution notices contained
within such NOTICE file, excluding those notices that do not
pertain to any part of the Derivative Works, in at least one
of the following places: within a NOTICE text file distributed
as part of the Derivative Works; within the Source form or
documentation, if provided along with the Derivative Works; or,
within a display generated by the Derivative Works, if and
wherever such third-party notices normally appear. The contents
of the NOTICE file are for informational purposes only and
do not modify the License. You may add Your own attribution
notices within Derivative Works that You distribute, alongside
or as an addendum to the NOTICE text from the Work, provided
that such additional attribution notices cannot be construed
as modifying the License.
You may add Your own copyright statement to Your modifications and
may provide additional or different license terms and conditions
for use, reproduction, or distribution of Your modifications, or
for any such Derivative Works as a whole, provided Your use,
reproduction, and distribution of the Work otherwise complies with
the conditions stated in this License.
5. Submission of Contributions. Unless You explicitly state otherwise,
any Contribution intentionally submitted for inclusion in the Work
by You to the Licensor shall be under the terms and conditions of
this License, without any additional terms or conditions.
Notwithstanding the above, nothing herein shall supersede or modify
the terms of any separate license agreement you may have executed
with Licensor regarding such Contributions.
6. Trademarks. This License does not grant permission to use the trade
names, trademarks, service marks, or product names of the Licensor,
except as required for reasonable and customary use in describing the
origin of the Work and reproducing the content of the NOTICE file.
7. Disclaimer of Warranty. Unless required by applicable law or
agreed to in writing, Licensor provides the Work (and each
Contributor provides its Contributions) on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
implied, including, without limitation, any warranties or conditions
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
PARTICULAR PURPOSE. You are solely responsible for determining the
appropriateness of using or redistributing the Work and assume any
risks associated with Your exercise of permissions under this License.
8. Limitation of Liability. In no event and under no legal theory,
whether in tort (including negligence), contract, or otherwise,
unless required by applicable law (such as deliberate and grossly
negligent acts) or agreed to in writing, shall any Contributor be
liable to You for damages, including any direct, indirect, special,
incidental, or consequential damages of any character arising as a
result of this License or out of the use or inability to use the
Work (including but not limited to damages for loss of goodwill,
work stoppage, computer failure or malfunction, or any and all
other commercial damages or losses), even if such Contributor
has been advised of the possibility of such damages.
9. Accepting Warranty or Additional Liability. While redistributing
the Work or Derivative Works thereof, You may choose to offer,
and charge a fee for, acceptance of support, warranty, indemnity,
or other liability obligations and/or rights consistent with this
License. However, in accepting such obligations, You may act only
on Your own behalf and on Your sole responsibility, not on behalf
of any other Contributor, and only if You agree to indemnify,
defend, and hold each Contributor harmless for any liability
incurred by, or claims asserted against, such Contributor by reason
of your accepting any such warranty or additional liability.
END OF TERMS AND CONDITIONS
APPENDIX: How to apply the Apache License to your work.
To apply the Apache License to your work, attach the following
boilerplate notice, with the fields enclosed by brackets "[]"
replaced with your own identifying information. (Don't include
the brackets!) The text should be enclosed in the appropriate
comment syntax for the file format. We also recommend that a
file or class name and description of purpose be included on the
same "printed page" as the copyright notice for easier
identification within third-party archives.
Copyright [yyyy] [name of copyright owner]
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License. atlas-0.7.2/README.md 0000664 0000000 0000000 00000005167 14314555116 0014121 0 ustar 00root root 0000000 0000000
Atlas CLI is an open source tool that helps developers manage their database schemas by applying modern DevOps principles. Contrary to existing tools, Atlas intelligently plans schema migrations for you. Atlas users can use the [Atlas DDL](https://atlasgo.io/guides/ddl#hcl) (data definition language) to describe their desired database schema and use the command-line tool to plan and apply the migrations to their systems.
## Quick Installation
On macOS:
```shell
brew install ariga/tap/atlas
```
Click [here](https://atlasgo.io/cli/getting-started/setting-up) to read instructions for other platforms.
## Getting Started
Get started with Atlas by following the [Getting Started](https://atlasgo.io/cli/getting-started/setting-up) docs.
This tutorial teaches you how to inspect a database, generate a migration plan and apply the migration to your database.
## Features
- **Inspecting a database**: easily inspect your database schema by providing a database URL.
```shell
atlas schema inspect -u "mysql://root:pass@localhost:3306/example" > atlas.hcl
```
- **Applying a migration**: generate a migration plan to apply on the database by providing an HCL file with the desired Atlas schema.
```shell
atlas schema apply -u "mysql://root:pass@localhost:3306/example" -f atlas.hcl
```
- **Declarative Migrations vs. Versioned Migrations**: Atlas offers two workflows. Declarative migrations allow the user to provide a desired state and Atlas gets the schema there instantly (simply using inspect and apply commands). Alternatively, versioned migrations are explicitly defined and assigned a version. Atlas can then bring a schema to the desired version by following the migrations between the current version and the specified one.
### About the Project
Read more about the motivation of the project [here](https://atlasgo.io/blog/2021/11/25/meet-atlas).
### Supported Databases
MySQL, MariaDB, PostgresSQL, SQLite, TiDB, CockroachDB
atlas-0.7.2/cmd/ 0000775 0000000 0000000 00000000000 14314555116 0013374 5 ustar 00root root 0000000 0000000 atlas-0.7.2/cmd/atlas/ 0000775 0000000 0000000 00000000000 14314555116 0014500 5 ustar 00root root 0000000 0000000 atlas-0.7.2/cmd/atlas/doc.go 0000664 0000000 0000000 00000002520 14314555116 0015573 0 ustar 00root root 0000000 0000000 // Copyright 2021-present The Atlas Authors. All rights reserved.
// This source code is licensed under the Apache 2.0 license found
// in the LICENSE file in the root directory of this source tree.
//go:build ignore
// +build ignore
package main
import (
"log"
"os"
"strings"
"text/template"
"ariga.io/atlas/cmd/atlas/internal/cmdapi"
"github.com/spf13/cobra"
)
func main() {
f, err := os.Create("../../doc/md/reference.md")
if err != nil {
log.Fatal(err)
}
t, err := template.New("").
Funcs(template.FuncMap{
"header": func(depth int) string {
return strings.Repeat("#", depth+1)
},
"subheader": func(depth int) string {
return strings.Repeat("#", depth+2)
},
}).
ParseFiles("doc.tmpl")
if err != nil {
log.Fatal(err)
}
if err := t.ExecuteTemplate(f, "header", nil); err != nil {
log.Fatal(err)
}
blocks := prepare(cmdapi.Root, make([]*block, 0), 0)
if err := t.ExecuteTemplate(f, "body", struct {
Blocks []*block
}{Blocks: blocks}); err != nil {
log.Fatal(err)
}
}
type block struct {
Depth int
*cobra.Command
}
func prepare(cmd *cobra.Command, existing []*block, depth int) []*block {
if depth > 0 {
existing = append(existing, &block{
Depth: depth,
Command: cmd,
})
}
for _, child := range cmd.Commands() {
existing = prepare(child, existing, depth+1)
}
return existing
}
atlas-0.7.2/cmd/atlas/doc.tmpl 0000664 0000000 0000000 00000002404 14314555116 0016143 0 ustar 00root root 0000000 0000000 {{- define "header" -}}
---
title: CLI Reference
id: cli-reference
slug: cli-reference
---
{{- end }}
{{ define "body" }}
## Introduction
This document serves as reference documentation for all available commands in the Atlas CLI.
Similar information can be obtained by running any atlas command with the `-h` or `--help`
flags.
For a more detailed introduction to the CLI capabilities, head over to the
[Getting Started](/getting-started/) page.
## Distributed Binaries
The binaries distributed in official releases are released under the [Ariga End User License](https://ariga.io/legal/atlas/eula).
If you would like to build Atlas from source follow the instructions [here](https://atlasgo.io/cli-reference#building-from-source).
### Building from Source
If you would like to build Atlas from source without the UI code run:
```shell
go get ariga.io/atlas/cmd/atlas
```
{{ range .Blocks }}
{{ header .Depth }} {{ .CommandPath }}
{{ .Short }}
{{- if .UseLine }}
#### Usage
```
{{ .UseLine }}
```
{{- end }}
{{- if .Long }}
#### Details
{{ .Long }}
{{- end }}
{{ if .Example }}
#### Example
```
{{ .Example }}
```
{{- end }}
{{- $flags := .NonInheritedFlags }}
{{- if $flags.HasAvailableFlags }}
#### Flags
```
{{ $flags.FlagUsages }}
```
{{ end }}
{{ end }}
{{ end }}
atlas-0.7.2/cmd/atlas/generate.go 0000664 0000000 0000000 00000000362 14314555116 0016622 0 ustar 00root root 0000000 0000000 // Copyright 2021-present The Atlas Authors. All rights reserved.
// This source code is licensed under the Apache 2.0 license found
// in the LICENSE file in the root directory of this source tree.
package main
//go:generate go run doc.go
atlas-0.7.2/cmd/atlas/go.mod 0000664 0000000 0000000 00000006222 14314555116 0015610 0 ustar 00root root 0000000 0000000 module ariga.io/atlas/cmd/atlas
go 1.18
require (
ariga.io/atlas v0.7.1-0.20220925103247-db83ea0cd178
entgo.io/ent v0.11.1
github.com/antlr/antlr4/runtime/Go/antlr v0.0.0-20220816024939-bc8df83d7b9d
github.com/auxten/postgresql-parser v1.0.1
github.com/fatih/color v1.13.0
github.com/go-sql-driver/mysql v1.6.0
github.com/hashicorp/hcl/v2 v2.13.0
github.com/lib/pq v1.10.6
github.com/manifoldco/promptui v0.9.0
github.com/mattn/go-sqlite3 v1.14.14
github.com/mitchellh/go-homedir v1.1.0
github.com/pingcap/tidb/parser v0.0.0-20220817134052-9709249e523a
github.com/spf13/cobra v1.5.0
github.com/spf13/pflag v1.0.5
github.com/stretchr/testify v1.8.0
golang.org/x/mod v0.6.0-dev.0.20211013180041-c96bc1413d57
)
require (
github.com/agext/levenshtein v1.2.1 // indirect
github.com/apparentlymart/go-textseg/v13 v13.0.0 // indirect
github.com/certifi/gocertifi v0.0.0-20200922220541-2c3bb06c6054 // indirect
github.com/chzyer/readline v1.5.1 // indirect
github.com/cockroachdb/apd v1.1.1-0.20181017181144-bced77f817b4 // indirect
github.com/cockroachdb/errors v1.8.2 // indirect
github.com/cockroachdb/logtags v0.0.0-20190617123548-eb05cc24525f // indirect
github.com/cockroachdb/redact v1.0.8 // indirect
github.com/cockroachdb/sentry-go v0.6.1-cockroachdb.2 // indirect
github.com/cznic/mathutil v0.0.0-20181122101859-297441e03548 // indirect
github.com/davecgh/go-spew v1.1.1 // indirect
github.com/dustin/go-humanize v1.0.0 // indirect
github.com/getsentry/raven-go v0.2.0 // indirect
github.com/go-openapi/inflect v0.19.0 // indirect
github.com/gogo/protobuf v1.3.2 // indirect
github.com/golang/protobuf v1.4.3 // indirect
github.com/google/go-cmp v0.5.6 // indirect
github.com/google/uuid v1.3.0 // indirect
github.com/grpc-ecosystem/grpc-gateway v1.16.0 // indirect
github.com/inconshreveable/mousetrap v1.0.0 // indirect
github.com/konsorten/go-windows-terminal-sequences v1.0.3 // indirect
github.com/kr/pretty v0.2.0 // indirect
github.com/kr/text v0.2.0 // indirect
github.com/mattn/go-colorable v0.1.9 // indirect
github.com/mattn/go-isatty v0.0.14 // indirect
github.com/mitchellh/go-wordwrap v0.0.0-20150314170334-ad45545899c7 // indirect
github.com/pingcap/errors v0.11.5-0.20210425183316-da1aaba5fb63 // indirect
github.com/pingcap/log v0.0.0-20210625125904-98ed8e2eb1c7 // indirect
github.com/pkg/errors v0.9.1 // indirect
github.com/pmezard/go-difflib v1.0.0 // indirect
github.com/remyoudompheng/bigfft v0.0.0-20200410134404-eec4a21b6bb0 // indirect
github.com/sirupsen/logrus v1.6.0 // indirect
github.com/zclconf/go-cty v1.8.0 // indirect
go.uber.org/atomic v1.7.0 // indirect
go.uber.org/multierr v1.6.0 // indirect
go.uber.org/zap v1.18.1 // indirect
golang.org/x/exp v0.0.0-20220428152302-39d4317da171 // indirect
golang.org/x/sync v0.0.0-20210220032951-036812b2e83c // indirect
golang.org/x/sys v0.0.0-20220829200755-d48e67d00261 // indirect
golang.org/x/text v0.3.7 // indirect
google.golang.org/genproto v0.0.0-20200911024640-645f7a48b24f // indirect
google.golang.org/grpc v1.33.1 // indirect
google.golang.org/protobuf v1.25.0 // indirect
gopkg.in/natefinch/lumberjack.v2 v2.0.0 // indirect
gopkg.in/yaml.v3 v3.0.1 // indirect
)
atlas-0.7.2/cmd/atlas/go.sum 0000664 0000000 0000000 00000132125 14314555116 0015637 0 ustar 00root root 0000000 0000000 ariga.io/atlas v0.6.4-0.20220830111134-f2d233c99aa1 h1:/8U7e/qiVREcJHKltZptJoa10gltLcUBVlcqU8gk1V8=
ariga.io/atlas v0.6.4-0.20220830111134-f2d233c99aa1/go.mod h1:ft47uSh5hWGDCmQC9DsztZg6Xk+KagM5Ts/mZYKb9JE=
ariga.io/atlas v0.6.4-0.20220831192411-1e893f70cbe8 h1:BmgIAqhnFoem+8/jhVAwm+YDRdfeMgcrbOxf/6+3Teg=
ariga.io/atlas v0.6.4-0.20220831192411-1e893f70cbe8/go.mod h1:ft47uSh5hWGDCmQC9DsztZg6Xk+KagM5Ts/mZYKb9JE=
ariga.io/atlas v0.6.5-0.20220907135005-d80f5e6b79cf h1:sqRKqa3gdunWKmv4G7FC0j4ROKJ8rG+6YoMBPTVGlxo=
ariga.io/atlas v0.6.5-0.20220907135005-d80f5e6b79cf/go.mod h1:ft47uSh5hWGDCmQC9DsztZg6Xk+KagM5Ts/mZYKb9JE=
ariga.io/atlas v0.7.0 h1:daEFdUsyNm7EHyzcMfjWwq/fVv48fCfad+dIGyobY1k=
ariga.io/atlas v0.7.0/go.mod h1:ft47uSh5hWGDCmQC9DsztZg6Xk+KagM5Ts/mZYKb9JE=
ariga.io/atlas v0.7.1-0.20220925103247-db83ea0cd178 h1:/fhqvnyyi4h5epqhIsDQW9NLkklDnQ0GRgQqfUhl9Pw=
ariga.io/atlas v0.7.1-0.20220925103247-db83ea0cd178/go.mod h1:ft47uSh5hWGDCmQC9DsztZg6Xk+KagM5Ts/mZYKb9JE=
cloud.google.com/go v0.26.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw=
cloud.google.com/go v0.34.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw=
entgo.io/ent v0.11.1 h1:im67R+2W3Nee2bNS2YnoYz8oAF0Qz4AOlIvKRIAEISY=
entgo.io/ent v0.11.1/go.mod h1:X5b1YfMayrRTgKGO//8IqpL7XJx0uqdeReEkxNpXROA=
github.com/AndreasBriese/bbloom v0.0.0-20190306092124-e2d15f34fcf9/go.mod h1:bOvUY6CB00SOBii9/FifXqc0awNKxLFCL/+pkDPuyl8=
github.com/BurntSushi/toml v0.3.1 h1:WXkYYl6Yr3qBf1K79EBnL4mak0OimBfB0XUf9Vl28OQ=
github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU=
github.com/CloudyKit/fastprinter v0.0.0-20170127035650-74b38d55f37a/go.mod h1:EFZQ978U7x8IRnstaskI3IysnWY5Ao3QgZUKOXlsAdw=
github.com/CloudyKit/jet v2.1.3-0.20180809161101-62edd43e4f88+incompatible/go.mod h1:HPYO+50pSWkPoj9Q/eq0aRGByCL6ScRlUmiEX5Zgm+w=
github.com/DATA-DOG/go-sqlmock v1.5.0 h1:Shsta01QNfFxHCfpW6YH2STWB0MudeXXEWMr20OEh60=
github.com/Joker/hpp v1.0.0/go.mod h1:8x5n+M1Hp5hC0g8okX3sR3vFQwynaX/UgSOM9MeBKzY=
github.com/Joker/jade v1.0.1-0.20190614124447-d475f43051e7/go.mod h1:6E6s8o2AE4KhCrqr6GRJjdC/gNfTdxkIXvuGZZda2VM=
github.com/Shopify/goreferrer v0.0.0-20181106222321-ec9c9a553398/go.mod h1:a1uqRtAwp2Xwc6WNPJEufxJ7fx3npB4UV/JOLmbu5I0=
github.com/agext/levenshtein v1.2.1 h1:QmvMAjj2aEICytGiWzmxoE0x2KZvE0fvmqMOfy2tjT8=
github.com/agext/levenshtein v1.2.1/go.mod h1:JEDfjyjHDjOF/1e4FlBE/PkbqA9OfWu2ki2W0IB5558=
github.com/ajg/form v1.5.1/go.mod h1:uL1WgH+h2mgNtvBq0339dVnzXdBETtL2LeUXaIv25UY=
github.com/antihax/optional v1.0.0/go.mod h1:uupD/76wgC+ih3iEmQUL+0Ugr19nfwCT1kdvxnR2qWY=
github.com/antlr/antlr4/runtime/Go/antlr v0.0.0-20220816024939-bc8df83d7b9d h1:0xIrH2lJbraclvJT3pvTf3u2oCAL60cAqiv4qRpz4EI=
github.com/antlr/antlr4/runtime/Go/antlr v0.0.0-20220816024939-bc8df83d7b9d/go.mod h1:F7bn7fEU90QkQ3tnmaTx3LTKLEDqnwWODIYppRQ5hnY=
github.com/apparentlymart/go-textseg/v13 v13.0.0 h1:Y+KvPE1NYz0xl601PVImeQfFyEy6iT90AvPUL1NNfNw=
github.com/apparentlymart/go-textseg/v13 v13.0.0/go.mod h1:ZK2fH7c4NqDTLtiYLvIkEghdlcqw7yxLeM89kiTRPUo=
github.com/armon/consul-api v0.0.0-20180202201655-eb2c6b5be1b6/go.mod h1:grANhF5doyWs3UAsr3K4I6qtAmlQcZDesFNEHPZAzj8=
github.com/auxten/postgresql-parser v1.0.1 h1:x+qiEHAe2cH55Kly64dWh4tGvUKEQwMmJgma7a1kbj4=
github.com/auxten/postgresql-parser v1.0.1/go.mod h1:Nf27dtv8EU1C+xNkoLD3zEwfgJfDDVi8Zl86gznxPvI=
github.com/aymerick/raymond v2.0.3-0.20180322193309-b565731e1464+incompatible/go.mod h1:osfaiScAUVup+UC9Nfq76eWqDhXlp+4UYaA8uhTBO6g=
github.com/benbjohnson/clock v1.1.0 h1:Q92kusRqC1XV2MjkWETPvjJVqKetz1OzxZB7mHJLju8=
github.com/benbjohnson/clock v1.1.0/go.mod h1:J11/hYXuz8f4ySSvYwY0FKfm+ezbsZBKZxNJlLklBHA=
github.com/census-instrumentation/opencensus-proto v0.2.1/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU=
github.com/certifi/gocertifi v0.0.0-20200922220541-2c3bb06c6054 h1:uH66TXeswKn5PW5zdZ39xEwfS9an067BirqA+P4QaLI=
github.com/certifi/gocertifi v0.0.0-20200922220541-2c3bb06c6054/go.mod h1:sGbDF6GwGcLpkNXPUTkMRoywsNa/ol15pxFe6ERfguA=
github.com/chzyer/logex v1.1.10 h1:Swpa1K6QvQznwJRcfTfQJmTE72DqScAa40E+fbHEXEE=
github.com/chzyer/logex v1.1.10/go.mod h1:+Ywpsq7O8HXn0nuIou7OrIPyXbp3wmkHB+jjWRnGsAI=
github.com/chzyer/logex v1.2.1 h1:XHDu3E6q+gdHgsdTPH6ImJMIp436vR6MPtH8gP05QzM=
github.com/chzyer/logex v1.2.1/go.mod h1:JLbx6lG2kDbNRFnfkgvh4eRJRPX1QCoOIWomwysCBrQ=
github.com/chzyer/readline v0.0.0-20180603132655-2972be24d48e h1:fY5BOSpyZCqRo5OhCuC+XN+r/bBCmeuuJtjz+bCNIf8=
github.com/chzyer/readline v0.0.0-20180603132655-2972be24d48e/go.mod h1:nSuG5e5PlCu98SY8svDHJxuZscDgtXS6KTTbou5AhLI=
github.com/chzyer/readline v1.5.1 h1:upd/6fQk4src78LMRzh5vItIt361/o4uq553V8B5sGI=
github.com/chzyer/readline v1.5.1/go.mod h1:Eh+b79XXUwfKfcPLepksvw2tcLE/Ct21YObkaSkeBlk=
github.com/chzyer/test v0.0.0-20180213035817-a1ea475d72b1 h1:q763qf9huN11kDQavWsoZXJNW3xEE4JJyHa5Q25/sd8=
github.com/chzyer/test v0.0.0-20180213035817-a1ea475d72b1/go.mod h1:Q3SI9o4m/ZMnBNeIyt5eFwwo7qiLfzFZmjNmxjkiQlU=
github.com/chzyer/test v1.0.0 h1:p3BQDXSxOhOG0P9z6/hGnII4LGiEPOYBhs8asl/fC04=
github.com/chzyer/test v1.0.0/go.mod h1:2JlltgoNkt4TW/z9V/IzDdFaMTM2JPIi26O1pF38GC8=
github.com/client9/misspell v0.3.4/go.mod h1:qj6jICC3Q7zFZvVWo7KLAzC3yx5G7kyvSDkc90ppPyw=
github.com/cncf/udpa/go v0.0.0-20191209042840-269d4d468f6f/go.mod h1:M8M6+tZqaGXZJjfX53e64911xZQV5JYwmTeXPW+k8Sc=
github.com/cockroachdb/apd v1.1.1-0.20181017181144-bced77f817b4 h1:XWEdfNxDkZI3DXXlpo0hZJ1xdaH/f3CKuZpk93pS/Y0=
github.com/cockroachdb/apd v1.1.1-0.20181017181144-bced77f817b4/go.mod h1:mdGz2CnkJrefFtlLevmE7JpL2zB9tKofya/6w7wWzNA=
github.com/cockroachdb/datadriven v1.0.0/go.mod h1:5Ib8Meh+jk1RlHIXej6Pzevx/NLlNvQB9pmSBZErGA4=
github.com/cockroachdb/errors v1.6.1/go.mod h1:tm6FTP5G81vwJ5lC0SizQo374JNCOPrHyXGitRJoDqM=
github.com/cockroachdb/errors v1.8.2 h1:rnnWK9Nn5kEMOGz9531HuDx/FOleL4NVH20VsDexVC8=
github.com/cockroachdb/errors v1.8.2/go.mod h1:qGwQn6JmZ+oMjuLwjWzUNqblqk0xl4CVV3SQbGwK7Ac=
github.com/cockroachdb/logtags v0.0.0-20190617123548-eb05cc24525f h1:o/kfcElHqOiXqcou5a3rIlMc7oJbMQkeLk0VQJ7zgqY=
github.com/cockroachdb/logtags v0.0.0-20190617123548-eb05cc24525f/go.mod h1:i/u985jwjWRlyHXQbwatDASoW0RMlZ/3i9yJHE2xLkI=
github.com/cockroachdb/redact v1.0.8 h1:8QG/764wK+vmEYoOlfobpe12EQcS81ukx/a4hdVMxNw=
github.com/cockroachdb/redact v1.0.8/go.mod h1:BVNblN9mBWFyMyqK1k3AAiSxhvhfK2oOZZ2lK+dpvRg=
github.com/cockroachdb/sentry-go v0.6.1-cockroachdb.2 h1:IKgmqgMQlVJIZj19CdocBeSfSaiCbEBZGKODaixqtHM=
github.com/cockroachdb/sentry-go v0.6.1-cockroachdb.2/go.mod h1:8BT+cPK6xvFOcRlk0R8eg+OTkcqI6baNH4xAkpiYVvQ=
github.com/codegangsta/inject v0.0.0-20150114235600-33e0aa1cb7c0/go.mod h1:4Zcjuz89kmFXt9morQgcfYZAYZ5n8WHjt81YYWIwtTM=
github.com/coreos/etcd v3.3.10+incompatible/go.mod h1:uF7uidLiAD3TWHmW31ZFd/JWoc32PjwdhPthX9715RE=
github.com/coreos/go-etcd v2.0.0+incompatible/go.mod h1:Jez6KQU2B/sWsbdaef3ED8NzMklzPG4d5KIOhIy30Tk=
github.com/coreos/go-semver v0.2.0/go.mod h1:nnelYz7RCh+5ahJtPPxZlU+153eP4D4r3EedlOD2RNk=
github.com/cpuguy83/go-md2man v1.0.10/go.mod h1:SmD6nW6nTyfqj6ABTjUi3V3JVMnlJmwcJI5acqYI6dE=
github.com/cpuguy83/go-md2man/v2 v2.0.2/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o=
github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E=
github.com/cznic/mathutil v0.0.0-20181122101859-297441e03548 h1:iwZdTE0PVqJCos1vaoKsclOGD3ADKpshg3SRtYBbwso=
github.com/cznic/mathutil v0.0.0-20181122101859-297441e03548/go.mod h1:e6NPNENfs9mPDVNRekM7lKScauxd5kXTr1Mfyig6TDM=
github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
github.com/dgraph-io/badger v1.6.0/go.mod h1:zwt7syl517jmP8s94KqSxTlM6IMsdhYy6psNgSztDR4=
github.com/dgrijalva/jwt-go v3.2.0+incompatible/go.mod h1:E3ru+11k8xSBh+hMPgOLZmtrrCbhqsmaPHjLKYnJCaQ=
github.com/dgryski/go-farm v0.0.0-20190423205320-6a90982ecee2/go.mod h1:SqUrOPUnsFjfmXRMNPybcSiG0BgUW2AuFH8PAnS2iTw=
github.com/dustin/go-humanize v1.0.0 h1:VSnTsYCnlFHaM2/igO1h6X3HA71jcobQuxemgkq4zYo=
github.com/dustin/go-humanize v1.0.0/go.mod h1:HtrtbFcZ19U5GC7JDqmcUSB87Iq5E25KnS6fMYU6eOk=
github.com/eknkc/amber v0.0.0-20171010120322-cdade1c07385/go.mod h1:0vRUJqYpeSZifjYj7uP3BG/gKcuzL9xWVV/Y+cK33KM=
github.com/envoyproxy/go-control-plane v0.9.0/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4=
github.com/envoyproxy/go-control-plane v0.9.1-0.20191026205805-5f8ba28d4473/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4=
github.com/envoyproxy/go-control-plane v0.9.4/go.mod h1:6rpuAdCZL397s3pYoYcLgu1mIlRU8Am5FuJP05cCM98=
github.com/envoyproxy/protoc-gen-validate v0.1.0/go.mod h1:iSmxcyjqTsJpI2R4NaDN7+kN2VEUnK/pcBlmesArF7c=
github.com/etcd-io/bbolt v1.3.3/go.mod h1:ZF2nL25h33cCyBtcyWeZ2/I3HQOfTP+0PIEvHjkjCrw=
github.com/fasthttp-contrib/websocket v0.0.0-20160511215533-1f3b11f56072/go.mod h1:duJ4Jxv5lDcvg4QuQr0oowTf7dz4/CR8NtyCooz9HL8=
github.com/fatih/color v1.13.0 h1:8LOYc1KYPPmyKMuN8QV2DNRWNbLo6LZ0iLs8+mlH53w=
github.com/fatih/color v1.13.0/go.mod h1:kLAiJbzzSOZDVNGyDpeOxJ47H46qBXwg5ILebYFFOfk=
github.com/fatih/structs v1.1.0/go.mod h1:9NiDSp5zOcgEDl+j00MP/WkGVPOlPRLejGD8Ga6PJ7M=
github.com/flosch/pongo2 v0.0.0-20190707114632-bbf5a6c351f4/go.mod h1:T9YF2M40nIgbVgp3rreNmTged+9HrbNTIQf1PsaIiTA=
github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo=
github.com/fsnotify/fsnotify v1.4.9/go.mod h1:znqG4EE+3YCdAaPaxE2ZRY/06pZUdp0tY4IgpuI1SZQ=
github.com/gavv/httpexpect v2.0.0+incompatible/go.mod h1:x+9tiU1YnrOvnB725RkpoLv1M62hOWzwo5OXotisrKc=
github.com/getsentry/raven-go v0.2.0 h1:no+xWJRb5ZI7eE8TWgIq1jLulQiIoLG0IfYxv5JYMGs=
github.com/getsentry/raven-go v0.2.0/go.mod h1:KungGk8q33+aIAZUIVWZDr2OfAEBsO49PX4NzFV5kcQ=
github.com/ghodss/yaml v1.0.0/go.mod h1:4dBDuWmgqj2HViK6kFavaiC9ZROes6MMH2rRYeMEF04=
github.com/gin-contrib/sse v0.0.0-20190301062529-5545eab6dad3/go.mod h1:VJ0WA2NBN22VlZ2dKZQPAPnyWw5XTlK1KymzLKsr59s=
github.com/gin-gonic/gin v1.4.0/go.mod h1:OW2EZn3DO8Ln9oIKOvM++LBO+5UPHJJDH72/q/3rZdM=
github.com/go-check/check v0.0.0-20180628173108-788fd7840127/go.mod h1:9ES+weclKsC9YodN5RgxqK/VD9HM9JsCSh7rNhMZE98=
github.com/go-errors/errors v1.0.1 h1:LUHzmkK3GUKUrL/1gfBUxAHzcev3apQlezX/+O7ma6w=
github.com/go-errors/errors v1.0.1/go.mod h1:f4zRHt4oKfwPJE5k8C9vpYG+aDHdBFUsgrm6/TyX73Q=
github.com/go-martini/martini v0.0.0-20170121215854-22fa46961aab/go.mod h1:/P9AEU963A2AYjv4d1V5eVL1CQbEJq6aCNHDDjibzu8=
github.com/go-openapi/inflect v0.19.0 h1:9jCH9scKIbHeV9m12SmPilScz6krDxKRasNNSNPXu/4=
github.com/go-openapi/inflect v0.19.0/go.mod h1:lHpZVlpIQqLyKwJ4N+YSc9hchQy/i12fJykb83CRBH4=
github.com/go-sql-driver/mysql v1.6.0 h1:BCTh4TKNUYmOmMUcQ3IipzF5prigylS7XXjEkfCHuOE=
github.com/go-sql-driver/mysql v1.6.0/go.mod h1:DCzpHaOWr8IXmIStZouvnhqoel9Qv2LBy8hT2VhHyBg=
github.com/go-test/deep v1.0.3 h1:ZrJSEWsXzPOxaZnFteGEfooLba+ju3FYIbOrS+rQd68=
github.com/gobwas/httphead v0.0.0-20180130184737-2c6c146eadee/go.mod h1:L0fX3K22YWvt/FAX9NnzrNzcI4wNYi9Yku4O0LKYflo=
github.com/gobwas/pool v0.2.0/go.mod h1:q8bcK0KcYlCgd9e7WYLm9LpyS+YeLd8JVDW6WezmKEw=
github.com/gobwas/ws v1.0.2/go.mod h1:szmBTxLgaFppYjEmNtny/v3w89xOydFnnZMcgRRu/EM=
github.com/gogo/googleapis v0.0.0-20180223154316-0cd9801be74a/go.mod h1:gf4bu3Q80BeJ6H1S1vYPm8/ELATdvryBaNFGgqEef3s=
github.com/gogo/protobuf v1.2.0/go.mod h1:r8qH/GZQm5c6nD/R0oafs1akxWv10x8SbQlK7atdtwQ=
github.com/gogo/protobuf v1.3.1/go.mod h1:SlYgWuQ5SjCEi6WLHjHCa1yvBfUnHcTbrrZtXPKa29o=
github.com/gogo/protobuf v1.3.2 h1:Ov1cvc58UF3b5XjBnZv7+opcTcQFZebYjWzi34vdm4Q=
github.com/gogo/protobuf v1.3.2/go.mod h1:P1XiOD3dCwIKUDQYPy72D8LYyHL2YPYrpS2s69NZV8Q=
github.com/gogo/status v1.1.0/go.mod h1:BFv9nrluPLmrS0EmGVvLaPNmRosr9KapBYd5/hpY1WM=
github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q=
github.com/golang/mock v1.1.1/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A=
github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
github.com/golang/protobuf v1.3.1/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
github.com/golang/protobuf v1.3.2/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
github.com/golang/protobuf v1.3.3/go.mod h1:vzj43D7+SQXF/4pzW/hwtAqwc6iTitCiVSaWz5lYuqw=
github.com/golang/protobuf v1.3.4/go.mod h1:vzj43D7+SQXF/4pzW/hwtAqwc6iTitCiVSaWz5lYuqw=
github.com/golang/protobuf v1.4.0-rc.1/go.mod h1:ceaxUfeHdC40wWswd/P6IGgMaK3YpKi5j83Wpe3EHw8=
github.com/golang/protobuf v1.4.0-rc.1.0.20200221234624-67d41d38c208/go.mod h1:xKAWHe0F5eneWXFV3EuXVDTCmh+JuBKY0li0aMyXATA=
github.com/golang/protobuf v1.4.0-rc.2/go.mod h1:LlEzMj4AhA7rCAGe4KMBDvJI+AwstrUpVNzEA03Pprs=
github.com/golang/protobuf v1.4.0-rc.4.0.20200313231945-b860323f09d0/go.mod h1:WU3c8KckQ9AFe+yFwt9sWVRKCVIyN9cPHBJSNnbL67w=
github.com/golang/protobuf v1.4.0/go.mod h1:jodUvKwWbYaEsadDk5Fwe5c77LiNKVO9IDvqG2KuDX0=
github.com/golang/protobuf v1.4.1/go.mod h1:U8fpvMrcmy5pZrNK1lt4xCsGvpyWQ/VVv6QDs8UjoX8=
github.com/golang/protobuf v1.4.2/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI=
github.com/golang/protobuf v1.4.3 h1:JjCZWpVbqXDqFVmTfYWEVTMIYrL/NPdPSCHPJ0T/raM=
github.com/golang/protobuf v1.4.3/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI=
github.com/gomodule/redigo v1.7.1-0.20190724094224-574c33c3df38/go.mod h1:B4C85qUVwatsJoIUNIfCRsp7qO0iAmpGFZ4EELWSbC4=
github.com/google/go-cmp v0.2.0/go.mod h1:oXzfMopK8JAjlY9xF4vHSVASa0yLyX7SntLO5aqRK0M=
github.com/google/go-cmp v0.3.0/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
github.com/google/go-cmp v0.3.1/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
github.com/google/go-cmp v0.4.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
github.com/google/go-cmp v0.5.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
github.com/google/go-cmp v0.5.1/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
github.com/google/go-cmp v0.5.6 h1:BKbKCqvP6I+rmFHt06ZmyQtvB8xAkWdhFyr0ZUNZcxQ=
github.com/google/go-cmp v0.5.6/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
github.com/google/go-querystring v1.0.0/go.mod h1:odCYkC5MyYFN7vkCjXpyrEuKhc/BUO6wN/zVPAxq5ck=
github.com/google/uuid v1.1.2/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
github.com/google/uuid v1.3.0 h1:t6JiXgmwXMjEs8VusXIJk2BXHsn+wx8BZdTaoZ5fu7I=
github.com/google/uuid v1.3.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
github.com/gopherjs/gopherjs v0.0.0-20181017120253-0766667cb4d1/go.mod h1:wJfORRmW1u3UXTncJ5qlYoELFm8eSnnEO6hX4iZ3EWY=
github.com/gorilla/websocket v1.4.0/go.mod h1:E7qHFY5m1UJ88s3WnNqhKjPHQ0heANvMoAMk2YaljkQ=
github.com/grpc-ecosystem/grpc-gateway v1.16.0 h1:gmcG1KaJ57LophUzW0Hy8NmPhnMZb4M0+kPpLofRdBo=
github.com/grpc-ecosystem/grpc-gateway v1.16.0/go.mod h1:BDjrQk3hbvj6Nolgz8mAMFbcEtjT1g+wF4CSlocrBnw=
github.com/hashicorp/go-version v1.2.0/go.mod h1:fltr4n8CU8Ke44wwGCBoEymUuxUHl09ZGVZPK5anwXA=
github.com/hashicorp/hcl v1.0.0/go.mod h1:E5yfLk+7swimpb2L/Alb/PJmXilQ/rhwaUYs4T20WEQ=
github.com/hashicorp/hcl/v2 v2.13.0 h1:0Apadu1w6M11dyGFxWnmhhcMjkbAiKCv7G1r/2QgCNc=
github.com/hashicorp/hcl/v2 v2.13.0/go.mod h1:e4z5nxYlWNPdDSNYX+ph14EvWYMFm3eP0zIUqPc2jr0=
github.com/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpOxQnU=
github.com/hydrogen18/memlistener v0.0.0-20141126152155-54553eb933fb/go.mod h1:qEIFzExnS6016fRpRfxrExeVn2gbClQA99gQhnIcdhE=
github.com/imkira/go-interpol v1.1.0/go.mod h1:z0h2/2T3XF8kyEPpRgJ3kmNv+C43p+I/CoI+jC3w2iA=
github.com/inconshreveable/mousetrap v1.0.0 h1:Z8tu5sraLXCXIcARxBp/8cbvlwVa7Z1NHg9XEKhtSvM=
github.com/inconshreveable/mousetrap v1.0.0/go.mod h1:PxqpIevigyE2G7u3NXJIT2ANytuPF1OarO4DADm73n8=
github.com/iris-contrib/blackfriday v2.0.0+incompatible/go.mod h1:UzZ2bDEoaSGPbkg6SAB4att1aAwTmVIx/5gCVqeyUdI=
github.com/iris-contrib/go.uuid v2.0.0+incompatible/go.mod h1:iz2lgM/1UnEf1kP0L/+fafWORmlnuysV2EMP8MW+qe0=
github.com/iris-contrib/i18n v0.0.0-20171121225848-987a633949d0/go.mod h1:pMCz62A0xJL6I+umB2YTlFRwWXaDFA0jy+5HzGiJjqI=
github.com/iris-contrib/schema v0.0.1/go.mod h1:urYA3uvUNG1TIIjOSCzHr9/LmbQo8LrOcOqfqxa4hXw=
github.com/json-iterator/go v1.1.6/go.mod h1:+SdeFBvtyEkXs7REEP0seUULqWtbJapLOCVDaaPEHmU=
github.com/jtolds/gls v4.20.0+incompatible/go.mod h1:QJZ7F/aHp+rZTRtaJ1ow/lLfFfVYBRgL+9YlvaHOwJU=
github.com/juju/errors v0.0.0-20181118221551-089d3ea4e4d5/go.mod h1:W54LbzXuIE0boCoNJfwqpmkKJ1O4TCTZMetAt6jGk7Q=
github.com/juju/loggo v0.0.0-20180524022052-584905176618/go.mod h1:vgyd7OREkbtVEN/8IXZe5Ooef3LQePvuBm9UWj6ZL8U=
github.com/juju/testing v0.0.0-20180920084828-472a3e8b2073/go.mod h1:63prj8cnj0tU0S9OHjGJn+b1h0ZghCndfnbQolrYTwA=
github.com/k0kubun/colorstring v0.0.0-20150214042306-9440f1994b88/go.mod h1:3w7q1U84EfirKl04SVQ/s7nPm1ZPhiXd34z40TNz36k=
github.com/kataras/golog v0.0.9/go.mod h1:12HJgwBIZFNGL0EJnMRhmvGA0PQGx8VFwrZtM4CqbAk=
github.com/kataras/iris/v12 v12.0.1/go.mod h1:udK4vLQKkdDqMGJJVd/msuMtN6hpYJhg/lSzuxjhO+U=
github.com/kataras/neffos v0.0.10/go.mod h1:ZYmJC07hQPW67eKuzlfY7SO3bC0mw83A3j6im82hfqw=
github.com/kataras/pio v0.0.0-20190103105442-ea782b38602d/go.mod h1:NV88laa9UiiDuX9AhMbDPkGYSPugBOV6yTZB1l2K9Z0=
github.com/kisielk/errcheck v1.2.0/go.mod h1:/BMXB+zMLi60iA8Vv6Ksmxu/1UDYcXs4uQLJ+jE2L00=
github.com/kisielk/errcheck v1.5.0/go.mod h1:pFxgyoBC7bSaBwPgfKdkLd5X25qrDl4LWUI2bnpBCr8=
github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck=
github.com/klauspost/compress v1.8.2/go.mod h1:RyIbtBH6LamlWaDj8nUwkbUhJ87Yi3uG0guNDohfE1A=
github.com/klauspost/compress v1.9.0/go.mod h1:RyIbtBH6LamlWaDj8nUwkbUhJ87Yi3uG0guNDohfE1A=
github.com/klauspost/cpuid v1.2.1/go.mod h1:Pj4uuM528wm8OyEC2QMXAi2YiTZ96dNQPGgoMS4s3ek=
github.com/konsorten/go-windows-terminal-sequences v1.0.3 h1:CE8S1cTafDpPvMhIxNJKvHsGVBgn1xWYf1NbHQhywc8=
github.com/konsorten/go-windows-terminal-sequences v1.0.3/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
github.com/kr/pretty v0.2.0 h1:s5hAObm+yFO5uHYt5dYjxi2rXrsnmRpJx4OYvIWUaQs=
github.com/kr/pretty v0.2.0/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfnI=
github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY=
github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE=
github.com/kylelemons/godebug v0.0.0-20170820004349-d65d576e9348 h1:MtvEpTB6LX3vkb4ax0b5D2DHbNAUsen0Gx5wZoq3lV4=
github.com/labstack/echo/v4 v4.1.11/go.mod h1:i541M3Fj6f76NZtHSj7TXnyM8n2gaodfvfxNnFqi74g=
github.com/labstack/gommon v0.3.0/go.mod h1:MULnywXg0yavhxWKc+lOruYdAhDwPK9wf0OL7NoOu+k=
github.com/lib/pq v1.9.0/go.mod h1:AlVN5x4E4T544tWzH6hKfbfQvm3HdbOxrmggDNAPY9o=
github.com/lib/pq v1.10.6 h1:jbk+ZieJ0D7EVGJYpL9QTz7/YW6UHbmdnZWYyK5cdBs=
github.com/lib/pq v1.10.6/go.mod h1:AlVN5x4E4T544tWzH6hKfbfQvm3HdbOxrmggDNAPY9o=
github.com/magiconair/properties v1.8.0/go.mod h1:PppfXfuXeibc/6YijjN8zIbojt8czPbwD3XqdrwzmxQ=
github.com/manifoldco/promptui v0.9.0 h1:3V4HzJk1TtXW1MTZMP7mdlwbBpIinw3HztaIlYthEiA=
github.com/manifoldco/promptui v0.9.0/go.mod h1:ka04sppxSGFAtxX0qhlYQjISsg9mR4GWtQEhdbn6Pgg=
github.com/mattn/go-colorable v0.1.2/go.mod h1:U0ppj6V5qS13XJ6of8GYAs25YV2eR4EVcfRqFIhoBtE=
github.com/mattn/go-colorable v0.1.9 h1:sqDoxXbdeALODt0DAeJCVp38ps9ZogZEAXjus69YV3U=
github.com/mattn/go-colorable v0.1.9/go.mod h1:u6P/XSegPjTcexA+o6vUJrdnUu04hMope9wVRipJSqc=
github.com/mattn/go-isatty v0.0.7/go.mod h1:Iq45c/XA43vh69/j3iqttzPXn0bhXyGjM0Hdxcsrc5s=
github.com/mattn/go-isatty v0.0.8/go.mod h1:Iq45c/XA43vh69/j3iqttzPXn0bhXyGjM0Hdxcsrc5s=
github.com/mattn/go-isatty v0.0.9/go.mod h1:YNRxwqDuOph6SZLI9vUUz6OYw3QyUt7WiY2yME+cCiQ=
github.com/mattn/go-isatty v0.0.12/go.mod h1:cbi8OIDigv2wuxKPP5vlRcQ1OAZbq2CE4Kysco4FUpU=
github.com/mattn/go-isatty v0.0.14 h1:yVuAays6BHfxijgZPzw+3Zlu5yQgKGP2/hcQbHb7S9Y=
github.com/mattn/go-isatty v0.0.14/go.mod h1:7GGIvUiUoEMVVmxf/4nioHXj79iQHKdU27kJ6hsGG94=
github.com/mattn/go-sqlite3 v1.14.14 h1:qZgc/Rwetq+MtyE18WhzjokPD93dNqLGNT3QJuLvBGw=
github.com/mattn/go-sqlite3 v1.14.14/go.mod h1:NyWgC/yNuGj7Q9rpYnZvas74GogHl5/Z4A/KQRfk6bU=
github.com/mattn/goveralls v0.0.2/go.mod h1:8d1ZMHsd7fW6IRPKQh46F2WRpyib5/X4FOpevwGNQEw=
github.com/mediocregopher/mediocre-go-lib v0.0.0-20181029021733-cb65787f37ed/go.mod h1:dSsfyI2zABAdhcbvkXqgxOxrCsbYeHCPgrZkku60dSg=
github.com/mediocregopher/radix/v3 v3.3.0/go.mod h1:EmfVyvspXz1uZEyPBMyGK+kjWiKQGvsUt6O3Pj+LDCQ=
github.com/microcosm-cc/bluemonday v1.0.2/go.mod h1:iVP4YcDBq+n/5fb23BhYFvIMq/leAFZyRl6bYmGDlGc=
github.com/mitchellh/go-homedir v1.1.0 h1:lukF9ziXFxDFPkA1vsr5zpc1XuPDn/wFntq5mG+4E0Y=
github.com/mitchellh/go-homedir v1.1.0/go.mod h1:SfyaCUpYCn1Vlf4IUYiD9fPX4A5wJrkLzIz1N1q0pr0=
github.com/mitchellh/go-wordwrap v0.0.0-20150314170334-ad45545899c7 h1:DpOJ2HYzCv8LZP15IdmG+YdwD2luVPHITV96TkirNBM=
github.com/mitchellh/go-wordwrap v0.0.0-20150314170334-ad45545899c7/go.mod h1:ZXFpozHsX6DPmq2I0TCekCxypsnAUbP2oI0UX1GXzOo=
github.com/mitchellh/mapstructure v1.1.2/go.mod h1:FVVH3fgwuzCH5S8UJGiWEs2h04kUh9fWfEaFds41c1Y=
github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
github.com/modern-go/reflect2 v1.0.1/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0=
github.com/moul/http2curl v1.0.0/go.mod h1:8UbvGypXm98wA/IqH45anm5Y2Z6ep6O31QGOAZ3H0fQ=
github.com/nats-io/nats.go v1.8.1/go.mod h1:BrFz9vVn0fU3AcH9Vn4Kd7W0NpJ651tD5omQ3M8LwxM=
github.com/nats-io/nkeys v0.0.2/go.mod h1:dab7URMsZm6Z/jp9Z5UGa87Uutgc2mVpXLC4B7TDb/4=
github.com/nats-io/nuid v1.0.1/go.mod h1:19wcPz3Ph3q0Jbyiqsd0kePYG7A95tJPxeL+1OSON2c=
github.com/niemeyer/pretty v0.0.0-20200227124842-a10e7caefd8e h1:fD57ERR4JtEqsWbfPhv4DMiApHyliiK5xCTNVSPiaAs=
github.com/niemeyer/pretty v0.0.0-20200227124842-a10e7caefd8e/go.mod h1:zD1mROLANZcx1PVRCS0qkT7pwLkGfwJo4zjcN/Tysno=
github.com/nxadm/tail v1.4.4/go.mod h1:kenIhsEOeOJmVchQTgglprH7qJGnHDVpk1VPCcaMI8A=
github.com/onsi/ginkgo v1.6.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
github.com/onsi/ginkgo v1.12.1/go.mod h1:zj2OWP4+oCPe1qIXoGWkgMRwljMUYCdkwsT2108oapk=
github.com/onsi/ginkgo v1.13.0/go.mod h1:+REjRxOmWfHCjfv9TTWB1jD1Frx4XydAD3zm1lskyM0=
github.com/onsi/gomega v1.7.1/go.mod h1:XdKZgCCFLUoM/7CFJVPcG8C1xQ1AJ0vpAezJrB7JYyY=
github.com/onsi/gomega v1.10.1/go.mod h1:iN09h71vgCQne3DLsj+A5owkum+a2tYe+TOCB1ybHNo=
github.com/pelletier/go-toml v1.2.0/go.mod h1:5z9KED0ma1S8pY6P1sdut58dfprrGBbd/94hg7ilaic=
github.com/petermattis/goid v0.0.0-20180202154549-b0b1615b78e5 h1:q2e307iGHPdTGp0hoxKjt1H5pDo6utceo3dQVK3I5XQ=
github.com/petermattis/goid v0.0.0-20180202154549-b0b1615b78e5/go.mod h1:jvVRKCrJTQWu0XVbaOlby/2lO20uSCHEMzzplHXte1o=
github.com/pingcap/errors v0.11.0/go.mod h1:Oi8TUi2kEtXXLMJk9l1cGmz20kV3TaQ0usTwv5KuLY8=
github.com/pingcap/errors v0.11.4/go.mod h1:Oi8TUi2kEtXXLMJk9l1cGmz20kV3TaQ0usTwv5KuLY8=
github.com/pingcap/errors v0.11.5-0.20210425183316-da1aaba5fb63 h1:+FZIDR/D97YOPik4N4lPDaUcLDF/EQPogxtlHB2ZZRM=
github.com/pingcap/errors v0.11.5-0.20210425183316-da1aaba5fb63/go.mod h1:X2r9ueLEUZgtx2cIogM0v4Zj5uvvzhuuiu7Pn8HzMPg=
github.com/pingcap/log v0.0.0-20210625125904-98ed8e2eb1c7 h1:k2BbABz9+TNpYRwsCCFS8pEEnFVOdbgEjL/kTlLuzZQ=
github.com/pingcap/log v0.0.0-20210625125904-98ed8e2eb1c7/go.mod h1:8AanEdAHATuRurdGxZXBz0At+9avep+ub7U1AGYLIMM=
github.com/pingcap/tidb/parser v0.0.0-20220817134052-9709249e523a h1:KhEhzJLyVSFT13yk/M2BQ7eE6Ofs7jBnALjc0ICZbsQ=
github.com/pingcap/tidb/parser v0.0.0-20220817134052-9709249e523a/go.mod h1:wjvp+T3/T9XYt0nKqGX3Kc1AKuyUcfno6LTc6b2A6ew=
github.com/pkg/errors v0.8.0/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
github.com/prometheus/client_model v0.0.0-20190812154241-14fe0d1b01d4/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
github.com/remyoudompheng/bigfft v0.0.0-20200410134404-eec4a21b6bb0 h1:OdAsTTz6OkFY5QxjkYwrChwuRruF69c169dPK26NUlk=
github.com/remyoudompheng/bigfft v0.0.0-20200410134404-eec4a21b6bb0/go.mod h1:qqbHyh8v60DhA7CoWK5oRCqLrMHRGoxYCSS9EjAz6Eo=
github.com/rogpeppe/fastuuid v1.2.0/go.mod h1:jVj6XXZzXRy/MSR5jhDC/2q6DgLz+nrA6LYCDYWNEvQ=
github.com/russross/blackfriday v1.5.2/go.mod h1:JO/DiYxRf+HjHt06OyowR9PTA263kcR/rfWxYHBV53g=
github.com/russross/blackfriday/v2 v2.1.0/go.mod h1:+Rmxgy9KzJVeS9/2gXHxylqXiyQDYRxCVz55jmeOWTM=
github.com/ryanuber/columnize v2.1.0+incompatible/go.mod h1:sm1tb6uqfes/u+d4ooFouqFdy9/2g9QGwK3SQygK0Ts=
github.com/sclevine/agouti v3.0.0+incompatible/go.mod h1:b4WX9W9L1sfQKXeJf1mUTLZKJ48R1S7H23Ji7oFO5Bw=
github.com/sergi/go-diff v1.1.0 h1:we8PVUC3FE2uYfodKH/nBHMSetSfHDR6scGdBi+erh0=
github.com/sergi/go-diff v1.1.0/go.mod h1:STckp+ISIX8hZLjrqAeVduY0gWCT9IjLuqbuNXdaHfM=
github.com/shurcooL/sanitized_anchor_name v1.0.0/go.mod h1:1NzhyTcUVG4SuEtjjoZeVRXNmyL/1OwPU0+IJeTBvfc=
github.com/sirupsen/logrus v1.6.0 h1:UBcNElsrwanuuMsnGSlYmtmgbb23qDR5dG+6X6Oo89I=
github.com/sirupsen/logrus v1.6.0/go.mod h1:7uNnSEd1DgxDLC74fIahvMZmmYsHGZGEOFrfsX/uA88=
github.com/smartystreets/assertions v0.0.0-20180927180507-b2de0cb4f26d/go.mod h1:OnSkiWE9lh6wB0YB77sQom3nweQdgAjqCqsofrRNTgc=
github.com/smartystreets/goconvey v1.6.4/go.mod h1:syvi0/a8iFYH4r/RixwvyeAJjdLS9QV7WQ/tjFTllLA=
github.com/spf13/afero v1.1.2/go.mod h1:j4pytiNVoe2o6bmDsKpLACNPDBIoEAkihy7loJ1B0CQ=
github.com/spf13/cast v1.3.0/go.mod h1:Qx5cxh0v+4UWYiBimWS+eyWzqEqokIECu5etghLkUJE=
github.com/spf13/cobra v0.0.5/go.mod h1:3K3wKZymM7VvHMDS9+Akkh4K60UwM26emMESw8tLCHU=
github.com/spf13/cobra v1.5.0 h1:X+jTBEBqF0bHN+9cSMgmfuvv2VHJ9ezmFNf9Y/XstYU=
github.com/spf13/cobra v1.5.0/go.mod h1:dWXEIy2H428czQCjInthrTRUg7yKbok+2Qi/yBIJoUM=
github.com/spf13/jwalterweatherman v1.0.0/go.mod h1:cQK4TGJAtQXfYWX+Ddv3mKDzgVb68N+wFjFa4jdeBTo=
github.com/spf13/pflag v1.0.3/go.mod h1:DYY7MBk1bdzusC3SYhjObp+wFpr4gzcvqqNjLnInEg4=
github.com/spf13/pflag v1.0.5 h1:iy+VFUOCP1a+8yFto/drg2CJ5u0yRoB7fZw3DKv/JXA=
github.com/spf13/pflag v1.0.5/go.mod h1:McXfInJRrz4CZXVZOBLb0bTZqETkiAhM9Iw0y3An2Bg=
github.com/spf13/viper v1.3.2/go.mod h1:ZiWeW+zYFKm7srdB9IoDzzZXaJaI5eL9QjNiN/DMA2s=
github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw=
github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
github.com/stretchr/testify v1.8.0 h1:pSgiaMZlXftHpm5L7V1+rVB+AZJydKsMxsQBIJw4PKk=
github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
github.com/ugorji/go v1.1.4/go.mod h1:uQMGLiO92mf5W77hV/PUCpI3pbzQx3CRekS0kk+RGrc=
github.com/ugorji/go/codec v0.0.0-20181204163529-d75b2dcb6bc8/go.mod h1:VFNgLljTbGfSG7qAOspJ7OScBnGdDN/yBr0sguwnwf0=
github.com/urfave/negroni v1.0.0/go.mod h1:Meg73S6kFm/4PpbYdq35yYWoCZ9mS/YSx+lKnmiohz4=
github.com/valyala/bytebufferpool v1.0.0/go.mod h1:6bBcMArwyJ5K/AmCkWv1jt77kVWyCJ6HpOuEn7z0Csc=
github.com/valyala/fasthttp v1.6.0/go.mod h1:FstJa9V+Pj9vQ7OJie2qMHdwemEDaDiSdBnvPM1Su9w=
github.com/valyala/fasttemplate v1.0.1/go.mod h1:UQGH1tvbgY+Nz5t2n7tXsz52dQxojPUpymEIMZ47gx8=
github.com/valyala/tcplisten v0.0.0-20161114210144-ceec8f93295a/go.mod h1:v3UYOV9WzVtRmSR+PDvWpU/qWl4Wa5LApYYX4ZtKbio=
github.com/vmihailenco/msgpack/v4 v4.3.12/go.mod h1:gborTTJjAo/GWTqqRjrLCn9pgNN+NXzzngzBKDPIqw4=
github.com/vmihailenco/tagparser v0.1.1/go.mod h1:OeAg3pn3UbLjkWt+rN9oFYB6u/cQgqMEUPoW2WPyhdI=
github.com/xeipuuv/gojsonpointer v0.0.0-20180127040702-4e3ac2762d5f/go.mod h1:N2zxlSyiKSe5eX1tZViRH5QA0qijqEDrYZiPEAiq3wU=
github.com/xeipuuv/gojsonreference v0.0.0-20180127040603-bd5ef7bd5415/go.mod h1:GwrjFmJcFw6At/Gs6z4yjiIwzuJ1/+UwLxMQDVQXShQ=
github.com/xeipuuv/gojsonschema v1.2.0/go.mod h1:anYRn/JVcOK2ZgGU+IjEV4nwlhoK5sQluxsYJ78Id3Y=
github.com/xordataexchange/crypt v0.0.3-0.20170626215501-b2862e3d0a77/go.mod h1:aYKd//L2LvnjZzWKhF00oedf4jCCReLcmhLdhm1A27Q=
github.com/yalp/jsonpath v0.0.0-20180802001716-5cc68e5049a0/go.mod h1:/LWChgwKmvncFJFHJ7Gvn9wZArjbV5/FppcK2fKk/tI=
github.com/yudai/gojsondiff v1.0.0/go.mod h1:AY32+k2cwILAkW1fbgxQ5mUmMiZFgLIV+FBNExI05xg=
github.com/yudai/golcs v0.0.0-20170316035057-ecda9a501e82/go.mod h1:lgjkn3NuSvDfVJdfcVVdX+jpBxNmX4rDAzaS45IcYoM=
github.com/yudai/pp v2.0.1+incompatible/go.mod h1:PuxR/8QJ7cyCkFp/aUDS+JY727OFEZkTdatxwunjIkc=
github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
github.com/zclconf/go-cty v1.8.0 h1:s4AvqaeQzJIu3ndv4gVIhplVD0krU+bgrcLSVUnaWuA=
github.com/zclconf/go-cty v1.8.0/go.mod h1:vVKLxnk3puL4qRAv72AO+W99LUD4da90g3uUAzyuvAk=
go.uber.org/atomic v1.3.2/go.mod h1:gD2HeocX3+yG+ygLZcrzQJaqmWj9AIm7n08wl/qW/PE=
go.uber.org/atomic v1.6.0/go.mod h1:sABNBOSYdrvTF6hTgEIbc7YasKWGhgEQZyfxyTvoXHQ=
go.uber.org/atomic v1.7.0 h1:ADUqmZGgLDDfbSL9ZmPxKTybcoEYHgpYfELNoN+7hsw=
go.uber.org/atomic v1.7.0/go.mod h1:fEN4uk6kAWBTFdckzkM89CLk9XfWZrxpCo0nPH17wJc=
go.uber.org/goleak v1.1.10 h1:z+mqJhf6ss6BSfSM671tgKyZBFPTTJM+HLxnhPC3wu0=
go.uber.org/goleak v1.1.10/go.mod h1:8a7PlsEVH3e/a/GLqe5IIrQx6GzcnRmZEufDUTk4A7A=
go.uber.org/multierr v1.1.0/go.mod h1:wR5kodmAFQ0UK8QlbwjlSNy0Z68gJhDJUG5sjR94q/0=
go.uber.org/multierr v1.6.0 h1:y6IPFStTAIT5Ytl7/XYmHvzXQ7S3g/IeZW9hyZ5thw4=
go.uber.org/multierr v1.6.0/go.mod h1:cdWPpRnG4AhwMwsgIHip0KRBQjJy5kYEpYjJxpXp9iU=
go.uber.org/zap v1.9.1/go.mod h1:vwi/ZaCAaUcBkycHslxD9B2zi4UTXhF60s6SWpuDF0Q=
go.uber.org/zap v1.18.1 h1:CSUJ2mjFszzEWt4CdKISEuChVIXGBn3lAPwkRGyVrc4=
go.uber.org/zap v1.18.1/go.mod h1:xg/QME4nWcxGxrpdeYfq7UvYrLh66cuVKdrbD1XF/NI=
golang.org/x/crypto v0.0.0-20181203042331-505ab145d0a9/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
golang.org/x/crypto v0.0.0-20190701094942-4def268fd1a4/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
golang.org/x/exp v0.0.0-20220428152302-39d4317da171 h1:TfdoLivD44QwvssI9Sv1xwa5DcL5XQr4au4sZ2F2NV4=
golang.org/x/exp v0.0.0-20220428152302-39d4317da171/go.mod h1:lgLbSvA5ygNOMpwM/9anMpWVlVJ7Z+cHWq/eFuinpGE=
golang.org/x/lint v0.0.0-20181026193005-c67002cb31c3/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE=
golang.org/x/lint v0.0.0-20190227174305-5b3e6a55c961/go.mod h1:wehouNa3lNwaWXcvxsM5YxQ5yQlVC4a0KAMCusXpPoU=
golang.org/x/lint v0.0.0-20190313153728-d0100b6bd8b3/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
golang.org/x/lint v0.0.0-20190930215403-16217165b5de h1:5hukYrvBGR8/eNkX5mdUezrA6JiaEZDtJb9Ei+1LlBs=
golang.org/x/lint v0.0.0-20190930215403-16217165b5de/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
golang.org/x/mod v0.6.0-dev.0.20211013180041-c96bc1413d57 h1:LQmS1nU0twXLA96Kt7U9qtHJEbBk3z6Q0V4UXjZkpr4=
golang.org/x/mod v0.6.0-dev.0.20211013180041-c96bc1413d57/go.mod h1:3p9vT2HGsQu2K1YbXdKPJLVgG5VJdoTa1poYQBtP1AY=
golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
golang.org/x/net v0.0.0-20180906233101-161cd47e91fd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
golang.org/x/net v0.0.0-20181220203305-927f97764cc3/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
golang.org/x/net v0.0.0-20190108225652-1e06a53dbb7e/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
golang.org/x/net v0.0.0-20190213061140-3a22650c66bd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
golang.org/x/net v0.0.0-20190327091125-710a502c58a2/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
golang.org/x/net v0.0.0-20190503192946-f4e77d36d62c/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
golang.org/x/net v0.0.0-20190603091049-60506f45cf65/go.mod h1:HSz+uSET+XFnRR8LxR5pz3Of3rY3CfYBVs4xY44aLks=
golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
golang.org/x/net v0.0.0-20190827160401-ba9fcec4b297/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
golang.org/x/net v0.0.0-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
golang.org/x/net v0.0.0-20200301022130-244492dfa37a/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
golang.org/x/net v0.0.0-20200520004742-59133d7f0dd7/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
golang.org/x/net v0.0.0-20200822124328-c89045814202/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA=
golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
golang.org/x/net v0.0.0-20201110031124-69a78807bb2b h1:uwuIcX0g4Yl1NC5XAz37xsr2lTtcqevgzYNVt49waME=
golang.org/x/net v0.0.0-20201110031124-69a78807bb2b/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
golang.org/x/oauth2 v0.0.0-20200107190931-bf48bf16ab8d/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
golang.org/x/sync v0.0.0-20181221193216-37e7f081c4d4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
golang.org/x/sync v0.0.0-20190227155943-e225da77a7e6/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
golang.org/x/sync v0.0.0-20210220032951-036812b2e83c h1:5KslGYwFpkhGh+Q16bwMP3cOontH8FOep7tGV86Y7SQ=
golang.org/x/sync v0.0.0-20210220032951-036812b2e83c/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
golang.org/x/sys v0.0.0-20180909124046-d0be0721c37e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
golang.org/x/sys v0.0.0-20181122145206-62eef0e2fa9b/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
golang.org/x/sys v0.0.0-20181205085412-a5c9d58dba9a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
golang.org/x/sys v0.0.0-20190222072716-a9d3bda3a223/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20190422165155-953cdadca894/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20190626221950-04f50cda93cb/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20190813064441-fde4db37ae7a/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20190904154756-749cb33beabd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20191005200804-aed5e4c7ecf9/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20191120155948-bd437916bb0e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20200116001909-b77594299b42/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20200223170610-d5e6a3e2c0ae/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20200519105757-fe76b779f299/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20201214210602-f9fddec55a1e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
golang.org/x/sys v0.0.0-20210630005230-0f9fa26af87c/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20211216021012-1d35b9e2eb4e h1:fLOSk5Q00efkSvAm+4xcoXD+RRmLmmulPn5I3Y9F2EM=
golang.org/x/sys v0.0.0-20211216021012-1d35b9e2eb4e/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20220310020820-b874c991c1a5/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20220829200755-d48e67d00261 h1:v6hYoSR9T5oet+pMXwUWkbiVqx/63mlHjefrHmxwfeY=
golang.org/x/sys v0.0.0-20220829200755-d48e67d00261/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
golang.org/x/text v0.3.4/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
golang.org/x/text v0.3.5/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
golang.org/x/text v0.3.7 h1:olpwvP2KacW1ZWvsR7uQhoyTYvKAupfQrRGBFM352Gk=
golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
golang.org/x/tools v0.0.0-20181030221726-6c7e314b6563/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
golang.org/x/tools v0.0.0-20181221001348-537d06c36207/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
golang.org/x/tools v0.0.0-20190114222345-bf090417da8b/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
golang.org/x/tools v0.0.0-20190226205152-f727befe758c/go.mod h1:9Yl7xja0Znq3iFh3HoIrodX9oNMXvdceNzlUR8zjMvY=
golang.org/x/tools v0.0.0-20190311212946-11955173bddd/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
golang.org/x/tools v0.0.0-20190327201419-c70d86f8b7cf/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
golang.org/x/tools v0.0.0-20190328211700-ab21143f2384/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
golang.org/x/tools v0.0.0-20190524140312-2c0ae7006135/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q=
golang.org/x/tools v0.0.0-20191029041327-9cc4af7d6b2c/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
golang.org/x/tools v0.0.0-20191108193012-7d206e10da11/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
golang.org/x/tools v0.0.0-20200619180055-7c47624df98f/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE=
golang.org/x/tools v0.0.0-20210106214847-113979e3529a/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
golang.org/x/tools v0.1.9-0.20211216111533-8d383106f7e7 h1:M1gcVrIb2lSn2FIL19DG0+/b8nNVKJ7W7b4WcAGZAYM=
golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 h1:go1bK/D/BFZV2I8cIQd1NKEZ+0owSTG1fDTci4IqFcE=
golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
google.golang.org/appengine v1.1.0/go.mod h1:EbEs0AVv82hx2wNQdGPgUI5lhzA/G0D9YwlJXL52JkM=
google.golang.org/appengine v1.4.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4=
google.golang.org/appengine v1.6.5/go.mod h1:8WjMMxjGQR8xUklV/ARdw2HLXBOI7O7uCIDZVag1xfc=
google.golang.org/genproto v0.0.0-20180518175338-11a468237815/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc=
google.golang.org/genproto v0.0.0-20180817151627-c66870c02cf8/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc=
google.golang.org/genproto v0.0.0-20190819201941-24fa4b261c55/go.mod h1:DMBHOl98Agz4BDEuKkezgsaosCRResVns1a3J2ZsMNc=
google.golang.org/genproto v0.0.0-20200513103714-09dca8ec2884/go.mod h1:55QSHmfGQM9UVYDPBsyGGes0y52j32PQ3BqQfXhyH3c=
google.golang.org/genproto v0.0.0-20200526211855-cb27e3aa2013/go.mod h1:NbSheEEYHJ7i3ixzK3sjbqSGDJWnxyFXZblF3eUsNvo=
google.golang.org/genproto v0.0.0-20200911024640-645f7a48b24f h1:Yv4xsIx7HZOoyUGSJ2ksDyWE2qIBXROsZKt2ny3hCGM=
google.golang.org/genproto v0.0.0-20200911024640-645f7a48b24f/go.mod h1:FWY/as6DDZQgahTzZj3fqbO1CbirC29ZNUFHwi0/+no=
google.golang.org/grpc v1.12.0/go.mod h1:yo6s7OP7yaDglbqo1J04qKzAhqBH6lvTonzMVmEdcZw=
google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c=
google.golang.org/grpc v1.23.0/go.mod h1:Y5yQAOtifL1yxbo5wqy6BxZv8vAUGQwXBOALyacEbxg=
google.golang.org/grpc v1.25.1/go.mod h1:c3i+UQWmh7LiEpx4sFZnkU36qjEYZ0imhYfXVyQciAY=
google.golang.org/grpc v1.27.0/go.mod h1:qbnxyOmOxrQa7FizSgH+ReBfzJrCY1pSN7KXBS8abTk=
google.golang.org/grpc v1.29.1/go.mod h1:itym6AZVZYACWQqET3MqgPpjcuV5QH3BxFS3IjizoKk=
google.golang.org/grpc v1.33.1 h1:DGeFlSan2f+WEtCERJ4J9GJWk15TxUi8QGagfI87Xyc=
google.golang.org/grpc v1.33.1/go.mod h1:fr5YgcSWrqhRRxogOsw7RzIpsmvOZ6IcH4kBYTpR3n0=
google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8=
google.golang.org/protobuf v0.0.0-20200221191635-4d8936d0db64/go.mod h1:kwYJMbMJ01Woi6D6+Kah6886xMZcty6N08ah7+eCXa0=
google.golang.org/protobuf v0.0.0-20200228230310-ab0ca4ff8a60/go.mod h1:cfTl7dwQJ+fmap5saPgwCLgHXTUD7jkjRqWcaiX5VyM=
google.golang.org/protobuf v1.20.1-0.20200309200217-e05f789c0967/go.mod h1:A+miEFZTKqfCUM6K7xSMQL9OKL/b6hQv+e19PK+JZNE=
google.golang.org/protobuf v1.21.0/go.mod h1:47Nbq4nVaFHyn7ilMalzfO3qCViNmqZ2kzikPIcrTAo=
google.golang.org/protobuf v1.22.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
google.golang.org/protobuf v1.23.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
google.golang.org/protobuf v1.23.1-0.20200526195155-81db48ad09cc/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
google.golang.org/protobuf v1.24.0/go.mod h1:r/3tXBNzIEhYS9I1OUVjXDlt8tc493IdKGjtUeSXeh4=
google.golang.org/protobuf v1.25.0 h1:Ejskq+SyPohKW+1uil0JJMtmHCgJPJ/qWTxr8qp+R4c=
google.golang.org/protobuf v1.25.0/go.mod h1:9JNX74DMeImyA3h4bdi1ymwjUzf21/xIlbajtzgsN7c=
gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
gopkg.in/check.v1 v1.0.0-20190902080502-41f04d3bba15/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
gopkg.in/check.v1 v1.0.0-20200227125254-8fa46927fb4f h1:BLraFXnmrev5lT+xlilqcH8XK9/i0At2xKjWk4p6zsU=
gopkg.in/check.v1 v1.0.0-20200227125254-8fa46927fb4f/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
gopkg.in/fsnotify.v1 v1.4.7/go.mod h1:Tz8NjZHkW78fSQdbUxIjBTcgA1z1m8ZHf0WmKUhAMys=
gopkg.in/go-playground/assert.v1 v1.2.1/go.mod h1:9RXL0bg/zibRAgZUYszZSwO/z8Y/a8bDuhia5mkpMnE=
gopkg.in/go-playground/validator.v8 v8.18.2/go.mod h1:RX2a/7Ha8BgOhfk7j780h4/u/RRjR0eouCJSH80/M2Y=
gopkg.in/mgo.v2 v2.0.0-20180705113604-9856a29383ce/go.mod h1:yeKp02qBN3iKW1OzL3MGk2IdtZzaj7SFntXj72NppTA=
gopkg.in/natefinch/lumberjack.v2 v2.0.0 h1:1Lc07Kr7qY4U2YPouBjpCLxpiyxIVoxqXgkXLknAOE8=
gopkg.in/natefinch/lumberjack.v2 v2.0.0/go.mod h1:l0ndWWf7gzL7RNwBG7wST/UCcT4T24xpD6X8LsfU/+k=
gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7/go.mod h1:dt/ZhP58zS4L8KSrWDmTeBkI65Dw0HsyUHuEVlX15mw=
gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
gopkg.in/yaml.v2 v2.2.3/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
gopkg.in/yaml.v2 v2.2.4/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
gopkg.in/yaml.v2 v2.2.8/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
gopkg.in/yaml.v2 v2.3.0/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
gopkg.in/yaml.v2 v2.4.0 h1:D8xgwECY7CYvx+Y2n4sBz93Jn9JRvxdiyyo8CTfuKaY=
gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ=
gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
gopkg.in/yaml.v3 v3.0.0-20200615113413-eeeca48fe776/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
gopkg.in/yaml.v3 v3.0.0-20210107192922-496545a6307b/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
honnef.co/go/tools v0.0.0-20190523083050-ea95bdfd59fc/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
atlas-0.7.2/cmd/atlas/go.work 0000664 0000000 0000000 00000000067 14314555116 0016014 0 ustar 00root root 0000000 0000000 go 1.18
use (
./
)
replace ariga.io/atlas => ../../
atlas-0.7.2/cmd/atlas/go.work.sum 0000664 0000000 0000000 00000033547 14314555116 0016630 0 ustar 00root root 0000000 0000000 cloud.google.com/go v0.34.0 h1:eOI3/cP2VTU6uZLDYAoic+eyzzB9YyGmJ7eIjl8rOPg=
github.com/AndreasBriese/bbloom v0.0.0-20190306092124-e2d15f34fcf9 h1:HD8gA2tkByhMAwYaFAX9w2l7vxvBQ5NMoxDrkhqhtn4=
github.com/CloudyKit/fastprinter v0.0.0-20170127035650-74b38d55f37a h1:3SgJcK9l5uPdBC/X17wanyJAMxM33+4ZhEIV96MIH8U=
github.com/CloudyKit/jet v2.1.3-0.20180809161101-62edd43e4f88+incompatible h1:rZgFj+Gtf3NMi/U5FvCvhzaxzW/TaPYgUYx3bAPz9DE=
github.com/Joker/hpp v1.0.0 h1:65+iuJYdRXv/XyN62C1uEmmOx3432rNG/rKlX6V7Kkc=
github.com/Joker/jade v1.0.1-0.20190614124447-d475f43051e7 h1:mreN1m/5VJ/Zc3b4pzj9qU6D9SRQ6Vm+3KfI328t3S8=
github.com/Shopify/goreferrer v0.0.0-20181106222321-ec9c9a553398 h1:WDC6ySpJzbxGWFh4aMxFFC28wwGp5pEuoTtvA4q/qQ4=
github.com/ajg/form v1.5.1 h1:t9c7v8JUKu/XxOGBU0yjNpaMloxGEJhUkqFRq0ibGeU=
github.com/antihax/optional v1.0.0 h1:xK2lYat7ZLaVVcIuj82J8kIro4V6kDe0AUDFboUCwcg=
github.com/apparentlymart/go-dump v0.0.0-20180507223929-23540a00eaa3 h1:ZSTrOEhiM5J5RFxEaFvMZVEAM1KvT1YzbEOwB2EAGjA=
github.com/apparentlymart/go-textseg v1.0.0 h1:rRmlIsPEEhUTIKQb7T++Nz/A5Q6C9IuX2wFoYVvnCs0=
github.com/armon/consul-api v0.0.0-20180202201655-eb2c6b5be1b6 h1:G1bPvciwNyF7IUmKXNt9Ak3m6u9DE1rF+RmtIkBpVdA=
github.com/aymerick/raymond v2.0.3-0.20180322193309-b565731e1464+incompatible h1:Ppm0npCCsmuR9oQaBtRuZcmILVE74aXE+AmrJj8L2ns=
github.com/census-instrumentation/opencensus-proto v0.2.1 h1:glEXhBS5PSLLv4IXzLA5yPRVX4bilULVyxxbrfOtDAk=
github.com/client9/misspell v0.3.4 h1:ta993UF76GwbvJcIo3Y68y/M3WxlpEHPWIGDkJYwzJI=
github.com/cncf/udpa/go v0.0.0-20191209042840-269d4d468f6f h1:WBZRG4aNOuI15bLRrCgN8fCq8E5Xuty6jGbmSNEvSsU=
github.com/cockroachdb/datadriven v1.0.0 h1:uhZrAfEayBecH2w2tZmhe20HJ7hDvrrA4x2Bg9YdZKM=
github.com/codegangsta/inject v0.0.0-20150114235600-33e0aa1cb7c0 h1:sDMmm+q/3+BukdIpxwO365v/Rbspp2Nt5XntgQRXq8Q=
github.com/coreos/etcd v3.3.10+incompatible h1:jFneRYjIvLMLhDLCzuTuU4rSJUjRplcJQ7pD7MnhC04=
github.com/coreos/go-etcd v2.0.0+incompatible h1:bXhRBIXoTm9BYHS3gE0TtQuyNZyeEMux2sDi4oo5YOo=
github.com/coreos/go-semver v0.2.0 h1:3Jm3tLmsgAYcjC+4Up7hJrFBPr+n7rAqYeSw/SZazuY=
github.com/cpuguy83/go-md2man v1.0.10 h1:BSKMNlYxDvnunlTymqtgONjNnaRV1sTpcovwwjF22jk=
github.com/cpuguy83/go-md2man/v2 v2.0.2 h1:p1EgwI/C7NhT0JmVkwCD2ZBK8j4aeHQX2pMHHBfMQ6w=
github.com/creack/pty v1.1.9 h1:uDmaGzcdjhF4i/plgjmEsriH11Y0o7RKapEf/LDaM3w=
github.com/cznic/sortutil v0.0.0-20181122101858-f5f958428db8 h1:LpMLYGyy67BoAFGda1NeOBQwqlv7nUXpm+rIVHGxZZ4=
github.com/cznic/strutil v0.0.0-20171016134553-529a34b1c186 h1:0rkFMAbn5KBKNpJyHQ6Prb95vIKanmAe62KxsrN+sqA=
github.com/dgraph-io/badger v1.6.0 h1:DshxFxZWXUcO0xX476VJC07Xsr6ZCBVRHKZ93Oh7Evo=
github.com/dgrijalva/jwt-go v3.2.0+incompatible h1:7qlOGliEKZXTDg6OTjfoBKDXWrumCAMpl/TFQ4/5kLM=
github.com/dgryski/go-farm v0.0.0-20190423205320-6a90982ecee2 h1:tdlZCpZ/P9DhczCTSixgIKmwPv6+wP5DGjqLYw5SUiA=
github.com/eknkc/amber v0.0.0-20171010120322-cdade1c07385 h1:clC1lXBpe2kTj2VHdaIu9ajZQe4kcEY9j0NsnDDBZ3o=
github.com/envoyproxy/go-control-plane v0.9.4 h1:rEvIZUSZ3fx39WIi3JkQqQBitGwpELBIYWeBVh6wn+E=
github.com/envoyproxy/protoc-gen-validate v0.1.0 h1:EQciDnbrYxy13PgWoY8AqoxGiPrpgBZ1R8UNe3ddc+A=
github.com/etcd-io/bbolt v1.3.3 h1:gSJmxrs37LgTqR/oyJBWok6k6SvXEUerFTbltIhXkBM=
github.com/fasthttp-contrib/websocket v0.0.0-20160511215533-1f3b11f56072 h1:DddqAaWDpywytcG8w/qoQ5sAN8X12d3Z3koB0C3Rxsc=
github.com/fatih/structs v1.1.0 h1:Q7juDM0QtcnhCpeyLGQKyg4TOIghuNXrkL32pHAUMxo=
github.com/flosch/pongo2 v0.0.0-20190707114632-bbf5a6c351f4 h1:GY1+t5Dr9OKADM64SYnQjw/w99HMYvQ0A8/JoUkxVmc=
github.com/fsnotify/fsnotify v1.4.9 h1:hsms1Qyu0jgnwNXIxa+/V/PDsU6CfLf6CNO8H7IWoS4=
github.com/gavv/httpexpect v2.0.0+incompatible h1:1X9kcRshkSKEjNJJxX9Y9mQ5BRfbxU5kORdjhlA1yX8=
github.com/ghodss/yaml v1.0.0 h1:wQHKEahhL6wmXdzwWG11gIVCkOv05bNOh+Rxn0yngAk=
github.com/gin-contrib/sse v0.0.0-20190301062529-5545eab6dad3 h1:t8FVkw33L+wilf2QiWkw0UV77qRpcH/JHPKGpKa2E8g=
github.com/gin-gonic/gin v1.4.0 h1:3tMoCCfM7ppqsR0ptz/wi1impNpT7/9wQtMZ8lr1mCQ=
github.com/go-check/check v0.0.0-20180628173108-788fd7840127 h1:0gkP6mzaMqkmpcJYCFOLkIBwI7xFExG03bbkOkCvUPI=
github.com/go-martini/martini v0.0.0-20170121215854-22fa46961aab h1:xveKWz2iaueeTaUgdetzel+U7exyigDYBryyVfV/rZk=
github.com/gobwas/httphead v0.0.0-20180130184737-2c6c146eadee h1:s+21KNqlpePfkah2I+gwHF8xmJWRjooY+5248k6m4A0=
github.com/gobwas/pool v0.2.0 h1:QEmUOlnSjWtnpRGHF3SauEiOsy82Cup83Vf2LcMlnc8=
github.com/gobwas/ws v1.0.2 h1:CoAavW/wd/kulfZmSIBt6p24n4j7tHgNVCjsfHVNUbo=
github.com/gogo/googleapis v0.0.0-20180223154316-0cd9801be74a h1:dR8+Q0uO5S2ZBcs2IH6VBKYwSxPo2vYCYq0ot0mu7xA=
github.com/gogo/status v1.1.0 h1:+eIkrewn5q6b30y+g/BJINVVdi2xH7je5MPJ3ZPK3JA=
github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b h1:VKtxabqXZkF25pY9ekfRL6a582T4P37/31XEstQ5p58=
github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da h1:oI5xCqsCo564l8iNU+DwB5epxmsaqB+rhGL0m5jtYqE=
github.com/golang/mock v1.1.1 h1:G5FRp8JnTd7RQH5kemVNlMeyXQAztQ3mOWV95KxsXH8=
github.com/gomodule/redigo v1.7.1-0.20190724094224-574c33c3df38 h1:y0Wmhvml7cGnzPa9nocn/fMraMH/lMDdeG+rkx4VgYY=
github.com/google/go-querystring v1.0.0 h1:Xkwi/a1rcvNg1PPYe5vI8GbeBY/jrVuDX5ASuANWTrk=
github.com/gopherjs/gopherjs v0.0.0-20181017120253-0766667cb4d1 h1:EGx4pi6eqNxGaHF6qqu48+N2wcFQ5qg5FXgOdqsJ5d8=
github.com/gorilla/websocket v1.5.0 h1:PPwGk2jz7EePpoHN/+ClbZu8SPxiqlu12wZP/3sWmnc=
github.com/hashicorp/go-version v1.2.0 h1:3vNe/fWF5CBgRIguda1meWhsZHy3m8gCJ5wx+dIzX/E=
github.com/hashicorp/hcl v1.0.0 h1:0Anlzjpi4vEasTeNFn2mLJgTSwt0+6sfsiTG8qcWGx4=
github.com/hpcloud/tail v1.0.0 h1:nfCOvKYfkgYP8hkirhJocXT2+zOD8yUNjXaWfTlyFKI=
github.com/hydrogen18/memlistener v0.0.0-20141126152155-54553eb933fb h1:EPRgaDqXpLFUJLXZdGLnBTy1l6CLiNAPnvn2l+kHit0=
github.com/imkira/go-interpol v1.1.0 h1:KIiKr0VSG2CUW1hl1jpiyuzuJeKUUpC8iM1AIE7N1Vk=
github.com/iris-contrib/blackfriday v2.0.0+incompatible h1:o5sHQHHm0ToHUlAJSTjW9UWicjJSDDauOOQ2AHuIVp4=
github.com/iris-contrib/go.uuid v2.0.0+incompatible h1:XZubAYg61/JwnJNbZilGjf3b3pB80+OQg2qf6c8BfWE=
github.com/iris-contrib/i18n v0.0.0-20171121225848-987a633949d0 h1:Kyp9KiXwsyZRTeoNjgVCrWks7D8ht9+kg6yCjh8K97o=
github.com/iris-contrib/schema v0.0.1 h1:10g/WnoRR+U+XXHWKBHeNy/+tZmM2kcAVGLOsz+yaDA=
github.com/jessevdk/go-flags v1.5.0 h1:1jKYvbxEjfUl0fmqTCOfonvskHHXMjBySTLW4y9LFvc=
github.com/json-iterator/go v1.1.12 h1:PV8peI4a0ysnczrg+LtxykD8LfKY9ML6u2jnxaEnrnM=
github.com/jtolds/gls v4.20.0+incompatible h1:xdiiI2gbIgH/gLH7ADydsJ1uDOEzR8yvV7C0MuV77Wo=
github.com/juju/errors v0.0.0-20181118221551-089d3ea4e4d5 h1:rhqTjzJlm7EbkELJDKMTU7udov+Se0xZkWmugr6zGok=
github.com/juju/loggo v0.0.0-20180524022052-584905176618 h1:MK144iBQF9hTSwBW/9eJm034bVoG30IshVm688T2hi8=
github.com/juju/testing v0.0.0-20180920084828-472a3e8b2073 h1:WQM1NildKThwdP7qWrNAFGzp4ijNLw8RlgENkaI4MJs=
github.com/k0kubun/colorstring v0.0.0-20150214042306-9440f1994b88 h1:uC1QfSlInpQF+M0ao65imhwqKnz3Q2z/d8PWZRMQvDM=
github.com/kataras/golog v0.0.9 h1:J7Dl82843nbKQDrQM/abbNJZvQjS6PfmkkffhOTXEpM=
github.com/kataras/iris/v12 v12.0.1 h1:Wo5S7GMWv5OAzJmvFTvss/C4TS1W0uo6LkDlSymT4rM=
github.com/kataras/neffos v0.0.10 h1:O06dvQlxjdWvzWbm2Bq+Si6psUhvSmEctAMk9Xujqms=
github.com/kataras/pio v0.0.0-20190103105442-ea782b38602d h1:V5Rs9ztEWdp58oayPq/ulmlqJJZeJP6pP79uP3qjcao=
github.com/kisielk/errcheck v1.5.0 h1:e8esj/e4R+SAOwFwN+n3zr0nYeCyeweozKfO23MvHzY=
github.com/kisielk/gotool v1.0.0 h1:AV2c/EiW3KqPNT9ZKl07ehoAGi4C5/01Cfbblndcapg=
github.com/klauspost/compress v1.9.0 h1:GhthINjveNZAdFUD8QoQYfjxnOONZgztK/Yr6M23UTY=
github.com/klauspost/cpuid v1.2.1 h1:vJi+O/nMdFt0vqm8NZBI6wzALWdA2X+egi0ogNyrC/w=
github.com/kr/pty v1.1.1 h1:VkoXIwSboBpnk99O/KFauAEILuNHv5DVFKZMBN/gUgw=
github.com/labstack/echo/v4 v4.1.11 h1:z0BZoArY4FqdpUEl+wlHp4hnr/oSR6MTmQmv8OHSoww=
github.com/labstack/gommon v0.3.0 h1:JEeO0bvc78PKdyHxloTKiF8BD5iGrH8T6MSeGvSgob0=
github.com/magiconair/properties v1.8.0 h1:LLgXmsheXeRoUOBOjtwPQCWIYqM/LU1ayDtDePerRcY=
github.com/mattn/go-runewidth v0.0.9 h1:Lm995f3rfxdpd6TSmuVCHVb/QhupuXlYr8sCI/QdE+0=
github.com/mattn/goveralls v0.0.2 h1:7eJB6EqsPhRVxvwEXGnqdO2sJI0PTsrWoTMXEk9/OQc=
github.com/mediocregopher/mediocre-go-lib v0.0.0-20181029021733-cb65787f37ed h1:3dQJqqDouawQgl3gBE1PNHKFkJYGEuFb1DbSlaxdosE=
github.com/mediocregopher/radix/v3 v3.3.0 h1:oacPXPKHJg0hcngVVrdtTnfGJiS+PtwoQwTBZGFlV4k=
github.com/microcosm-cc/bluemonday v1.0.2 h1:5lPfLTTAvAbtS0VqT+94yOtFnGfUWYyx0+iToC3Os3s=
github.com/mitchellh/mapstructure v1.5.0 h1:jeMsZIYE/09sWLaz43PL7Gy6RuMjD2eJVyuac5Z2hdY=
github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd h1:TRLaZ9cD/w8PVh93nsPXa1VrQ6jlwL5oN8l14QlcNfg=
github.com/modern-go/reflect2 v1.0.2 h1:xBagoLtFs94CBntxluKeaWgTMpvLxC4ur3nMaC9Gz0M=
github.com/moul/http2curl v1.0.0 h1:dRMWoAtb+ePxMlLkrCbAqh4TlPHXvoGUSQ323/9Zahs=
github.com/nats-io/nats.go v1.8.1 h1:6lF/f1/NN6kzUDBz6pyvQDEXO39jqXcWRLu/tKjtOUQ=
github.com/nats-io/nkeys v0.0.2 h1:+qM7QpgXnvDDixitZtQUBDY9w/s9mu1ghS+JIbsrx6M=
github.com/nats-io/nuid v1.0.1 h1:5iA8DT8V7q8WK2EScv2padNa/rTESc1KdnPw4TC2paw=
github.com/nxadm/tail v1.4.4 h1:DQuhQpB1tVlglWS2hLQ5OV6B5r8aGxSrPc5Qo6uTN78=
github.com/olekukonko/tablewriter v0.0.5 h1:P2Ga83D34wi1o9J6Wh1mRuqd4mF/x/lgBS7N7AbDhec=
github.com/onsi/ginkgo v1.13.0 h1:M76yO2HkZASFjXL0HSoZJ1AYEmQxNJmY41Jx1zNUq1Y=
github.com/onsi/gomega v1.10.1 h1:o0+MgICZLuZ7xjH7Vx6zS/zcu93/BEp1VwkIW1mEXCE=
github.com/pelletier/go-toml v1.2.0 h1:T5zMGML61Wp+FlcbWjRDT7yAxhJNAiPPLOFECq181zc=
github.com/prometheus/client_model v0.0.0-20190812154241-14fe0d1b01d4 h1:gQz4mCbXsO+nc9n1hCxHcGA3Zx3Eo+UHZoInFGUIXNM=
github.com/rogpeppe/fastuuid v1.2.0 h1:Ppwyp6VYCF1nvBTXL3trRso7mXMlRrw9ooo375wvi2s=
github.com/russross/blackfriday v1.5.2 h1:HyvC0ARfnZBqnXwABFeSZHpKvJHJJfPz81GNueLj0oo=
github.com/russross/blackfriday/v2 v2.1.0 h1:JIOH55/0cWyOuilr9/qlrm0BSXldqnqwMsf35Ld67mk=
github.com/ryanuber/columnize v2.1.0+incompatible h1:j1Wcmh8OrK4Q7GXY+V7SVSY8nUWQxHW5TkBe7YUl+2s=
github.com/sclevine/agouti v3.0.0+incompatible h1:8IBJS6PWz3uTlMP3YBIR5f+KAldcGuOeFkFbUWfBgK4=
github.com/shurcooL/sanitized_anchor_name v1.0.0 h1:PdmoCO6wvbs+7yrJyMORt4/BmY5IYyJwS/kOiWx8mHo=
github.com/smartystreets/assertions v0.0.0-20180927180507-b2de0cb4f26d h1:zE9ykElWQ6/NYmHa3jpm/yHnI4xSofP+UP6SpjHcSeM=
github.com/smartystreets/goconvey v1.6.4 h1:fv0U8FUIMPNf1L9lnHLvLhgicrIVChEkdzIKYqbNC9s=
github.com/spf13/afero v1.1.2 h1:m8/z1t7/fwjysjQRYbP0RD+bUIF/8tJwPdEZsI83ACI=
github.com/spf13/cast v1.3.0 h1:oget//CVOEoFewqQxwr0Ej5yjygnqGkvggSE/gB35Q8=
github.com/spf13/jwalterweatherman v1.0.0 h1:XHEdyB+EcvlqZamSM4ZOMGlc93t6AcsBEu9Gc1vn7yk=
github.com/spf13/viper v1.3.2 h1:VUFqw5KcqRf7i70GOzW7N+Q7+gxVBkSSqiXB12+JQ4M=
github.com/stretchr/objx v0.4.0 h1:M2gUjqZET1qApGOWNSnZ49BAIMX4F/1plDv3+l31EJ4=
github.com/ugorji/go v1.1.4 h1:j4s+tAvLfL3bZyefP2SEWmhBzmuIlH/eqNuPdFPgngw=
github.com/ugorji/go/codec v0.0.0-20181204163529-d75b2dcb6bc8 h1:3SVOIvH7Ae1KRYyQWRjXWJEA9sS/c/pjvH++55Gr648=
github.com/urfave/negroni v1.0.0 h1:kIimOitoypq34K7TG7DUaJ9kq/N4Ofuwi1sjz0KipXc=
github.com/valyala/bytebufferpool v1.0.0 h1:GqA5TC/0021Y/b9FG4Oi9Mr3q7XYx6KllzawFIhcdPw=
github.com/valyala/fasthttp v1.6.0 h1:uWF8lgKmeaIewWVPwi4GRq2P6+R46IgYZdxWtM+GtEY=
github.com/valyala/fasttemplate v1.0.1 h1:tY9CJiPnMXf1ERmG2EyK7gNUd+c6RKGD0IfU8WdUSz8=
github.com/valyala/tcplisten v0.0.0-20161114210144-ceec8f93295a h1:0R4NLDRDZX6JcmhJgXi5E4b8Wg84ihbmUKp/GvSPEzc=
github.com/vmihailenco/msgpack/v4 v4.3.12 h1:07s4sz9IReOgdikxLTKNbBdqDMLsjPKXwvCazn8G65U=
github.com/vmihailenco/tagparser v0.1.1 h1:quXMXlA39OCbd2wAdTsGDlK9RkOk6Wuw+x37wVyIuWY=
github.com/xeipuuv/gojsonpointer v0.0.0-20180127040702-4e3ac2762d5f h1:J9EGpcZtP0E/raorCMxlFGSTBrsSlaDGf3jU/qvAE2c=
github.com/xeipuuv/gojsonreference v0.0.0-20180127040603-bd5ef7bd5415 h1:EzJWgHovont7NscjpAxXsDA8S8BMYve8Y5+7cuRE7R0=
github.com/xeipuuv/gojsonschema v1.2.0 h1:LhYJRs+L4fBtjZUfuSZIKGeVu0QRy8e5Xi7D17UxZ74=
github.com/xordataexchange/crypt v0.0.3-0.20170626215501-b2862e3d0a77 h1:ESFSdwYZvkeru3RtdrYueztKhOBCSAAzS4Gf+k0tEow=
github.com/yalp/jsonpath v0.0.0-20180802001716-5cc68e5049a0 h1:6fRhSjgLCkTD3JnJxvaJ4Sj+TYblw757bqYgZaOq5ZY=
github.com/yudai/gojsondiff v1.0.0 h1:27cbfqXLVEJ1o8I6v3y9lg8Ydm53EKqHXAOMxEGlCOA=
github.com/yudai/golcs v0.0.0-20170316035057-ecda9a501e82 h1:BHyfKlQyqbsFN5p3IfnEUduWvb9is428/nNb5L3U01M=
github.com/yudai/pp v2.0.1+incompatible h1:Q4//iY4pNF6yPLZIigmvcl7k/bPgrcTPIFIcmawg5bI=
github.com/yuin/goldmark v1.2.1 h1:ruQGxdhGHe7FWOJPT0mKs5+pD2Xs1Bm/kdGlHO04FmM=
github.com/zclconf/go-cty-debug v0.0.0-20191215020915-b22d67c1ba0b h1:FosyBZYxY34Wul7O/MSKey3txpPYyCqVO5ZyceuQJEI=
go.opencensus.io v0.23.0 h1:gqCw0LfLxScz8irSi8exQc7fyQ0fKQU/qnC/X8+V/1M=
golang.org/x/crypto v0.0.0-20220517005047-85d78b3ac167 h1:O8uGbHCqlTp2P6QJSLmCojM4mN6UemYv8K+dCnmHmu0=
golang.org/x/mod v0.6.0-dev.0.20211013180041-c96bc1413d57 h1:LQmS1nU0twXLA96Kt7U9qtHJEbBk3z6Q0V4UXjZkpr4=
golang.org/x/oauth2 v0.0.0-20200107190931-bf48bf16ab8d h1:TzXSXBo42m9gQenoE3b9BGiEpg5IG2JkU5FkPIawgtw=
golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1 h1:v+OssWQX+hTHEmOBgwxdZxK4zHq3yOs8F9J7mk0PY8E=
golang.org/x/tools v0.1.9-0.20211216111533-8d383106f7e7 h1:M1gcVrIb2lSn2FIL19DG0+/b8nNVKJ7W7b4WcAGZAYM=
google.golang.org/appengine v1.6.5 h1:tycE03LOZYQNhDpS27tcQdAzLCVMaj7QT2SXxebnpCM=
gopkg.in/fsnotify.v1 v1.4.7 h1:xOHLXZwVvI9hhs+cLKq5+I5onOuwQLhQwiu63xxlHs4=
gopkg.in/go-playground/assert.v1 v1.2.1 h1:xoYuJVE7KT85PYWrN730RguIQO0ePzVRfFMXadIrXTM=
gopkg.in/go-playground/validator.v8 v8.18.2 h1:lFB4DoMU6B626w8ny76MV7VX6W2VHct2GVOI3xgiMrQ=
gopkg.in/mgo.v2 v2.0.0-20180705113604-9856a29383ce h1:xcEWjVhvbDy+nHP67nPDDpbYrY+ILlfndk4bRioVHaU=
gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7 h1:uRGJdciOHaEIrze2W8Q3AKkepLTh2hOroT7a+7czfdQ=
honnef.co/go/tools v0.0.0-20190523083050-ea95bdfd59fc h1:/hemPrYIhOhy8zYrNj+069zDB68us2sMGsfkFJO0iZs=
modernc.org/golex v1.0.1 h1:EYKY1a3wStt0RzHaH8mdSRNg78Ub0OHxYfCRWw35YtM=
modernc.org/mathutil v1.4.1 h1:ij3fYGe8zBF4Vu+g0oT7mB06r8sqGWKuJu1yXeR4by8=
modernc.org/parser v1.0.2 h1:/qHLDn1ezrcRk9/XbErYp84bPPM4+w0kIDuvMdRk6Vc=
modernc.org/sortutil v1.0.0 h1:SUTM1sCR0Ldpv7dbB/KCPC2zHHsZ1KrSkhmGmmV22CQ=
modernc.org/strutil v1.1.0 h1:+1/yCzZxY2pZwwrsbH+4T7BQMoLQ9QiBshRC9eicYsc=
modernc.org/y v1.0.1 h1:+QT+MtLkwkvLkh3fYQq+YD5vw2s5paVE73jdl5R/Py8=
atlas-0.7.2/cmd/atlas/internal/ 0000775 0000000 0000000 00000000000 14314555116 0016314 5 ustar 00root root 0000000 0000000 atlas-0.7.2/cmd/atlas/internal/cmdapi/ 0000775 0000000 0000000 00000000000 14314555116 0017551 5 ustar 00root root 0000000 0000000 atlas-0.7.2/cmd/atlas/internal/cmdapi/cmdapi.go 0000664 0000000 0000000 00000010634 14314555116 0021341 0 ustar 00root root 0000000 0000000 // Copyright 2021-present The Atlas Authors. All rights reserved.
// This source code is licensed under the Apache 2.0 license found
// in the LICENSE file in the root directory of this source tree.
// Package cmdapi holds the atlas commands used to build
// an atlas distribution.
package cmdapi
import (
"fmt"
"os"
"strings"
"ariga.io/atlas/cmd/atlas/internal/update"
"github.com/spf13/cobra"
"golang.org/x/mod/semver"
)
var (
// Root represents the root command when called without any subcommands.
Root = &cobra.Command{
Use: "atlas",
Short: "A database toolkit.",
SilenceUsage: true,
}
// GlobalFlags contains flags common to many Atlas sub-commands.
GlobalFlags struct {
// SelectedEnv contains the environment selected from the active
// project via the --env flag.
SelectedEnv string
// Vars contains the input variables passed from the CLI to
// Atlas DDL or project files.
Vars map[string]string
}
// version holds Atlas version. When built with cloud packages
// should be set by build flag. "-X 'ariga.io/atlas/cmd/atlas/internal/cmdapi.version=${version}'"
version string
// schemaCmd represents the subcommand 'atlas version'.
versionCmd = &cobra.Command{
Use: "version",
Short: "Prints this Atlas CLI version information.",
Run: func(cmd *cobra.Command, args []string) {
v, u := parse(version)
Root.Printf("atlas version %s\n%s\n", v, u)
},
}
// EnvCmd represents the subcommand 'atlas env'.
EnvCmd = &cobra.Command{
Use: "env",
Short: "Print atlas environment variables.",
Long: `'atlas env' prints atlas environment information.
Every set environment param will be printed in the form of NAME=VALUE.
List of supported environment parameters:
* ATLAS_NO_UPDATE_NOTIFIER: On any command, the CLI will check for new releases using the GitHub API.
This check will happen at most once every 24 hours. To cancel this behavior, set the environment
variable "ATLAS_NO_UPDATE_NOTIFIER".`,
Run: func(cmd *cobra.Command, args []string) {
keys := []string{update.AtlasNoUpdateNotifier}
for _, k := range keys {
if v, ok := os.LookupEnv(k); ok {
cmd.Println(fmt.Sprintf("%s=%s", k, v))
}
}
},
}
// license holds Atlas license. When built with cloud packages
// should be set by build flag. "-X 'ariga.io/atlas/cmd/atlas/internal/cmdapi.license=${license}'"
license = `LICENSE
Atlas is licensed under Apache 2.0 as found in https://github.com/ariga/atlas/blob/master/LICENSE.`
licenseCmd = &cobra.Command{
Use: "license",
Short: "Display license information",
Run: func(cmd *cobra.Command, _ []string) {
cmd.Println(license)
},
}
)
// CheckForUpdate exposes internal update logic to CLI.
func CheckForUpdate() {
update.Check(version, Root.PrintErrln)
}
func init() {
Root.AddCommand(EnvCmd)
Root.AddCommand(schemaCmd)
Root.AddCommand(versionCmd)
Root.AddCommand(licenseCmd)
}
// receivesEnv configures cmd to receive the common '--env' flag.
func receivesEnv(cmd *cobra.Command) {
cmd.PersistentFlags().StringVarP(&GlobalFlags.SelectedEnv, "env", "", "", "set which env from the project file to use")
cmd.PersistentFlags().StringToStringVarP(&GlobalFlags.Vars, varFlag, "", nil, "input variables")
}
// inputValsFromEnv populates GlobalFlags.Vars from the active environment. If we are working
// inside a project, the "var" flag is not propagated to the schema definition. Instead, it
// is used to evaluate the project file which can pass input values via the "values" block
// to the schema.
func inputValsFromEnv(cmd *cobra.Command) error {
activeEnv, err := selectEnv(GlobalFlags.SelectedEnv)
if err != nil {
return err
}
if fl := cmd.Flag(varFlag); fl == nil {
return nil
}
values, err := activeEnv.asMap()
if err != nil {
return err
}
if len(values) == 0 {
return nil
}
pairs := make([]string, 0, len(values))
for k, v := range values {
pairs = append(pairs, fmt.Sprintf("%s=%s", k, v))
}
vars := strings.Join(pairs, ",")
if err := cmd.Flags().Set(varFlag, vars); err != nil {
return err
}
return nil
}
// parse returns a user facing version and release notes url
func parse(version string) (string, string) {
u := "https://github.com/ariga/atlas/releases/latest"
if ok := semver.IsValid(version); !ok {
return "- development", u
}
s := strings.Split(version, "-")
if len(s) != 0 && s[len(s)-1] != "canary" {
u = fmt.Sprintf("https://github.com/ariga/atlas/releases/tag/%s", version)
}
return version, u
}
atlas-0.7.2/cmd/atlas/internal/cmdapi/cmdapi_test.go 0000664 0000000 0000000 00000003664 14314555116 0022405 0 ustar 00root root 0000000 0000000 // Copyright 2021-present The Atlas Authors. All rights reserved.
// This source code is licensed under the Apache 2.0 license found
// in the LICENSE file in the root directory of this source tree.
package cmdapi
import (
"bytes"
"os"
"os/exec"
"testing"
"ariga.io/atlas/cmd/atlas/internal/update"
"github.com/stretchr/testify/require"
)
func TestEnv(t *testing.T) {
out, err := runCmd(Root, "env")
require.NoError(t, err)
require.Empty(t, out)
}
func TestEnv_Set(t *testing.T) {
err := os.Setenv(update.AtlasNoUpdateNotifier, "test")
require.NoError(t, err)
out, err := runCmd(Root, "env")
require.NoError(t, err)
require.Equal(t, "ATLAS_NO_UPDATE_NOTIFIER=test\n", out)
}
func TestCLI_Version(t *testing.T) {
// Required to have a clean "stderr" while running first time.
tests := []struct {
name string
cmd *exec.Cmd
expected string
}{
{
name: "dev mode",
cmd: exec.Command("go", "run", "ariga.io/atlas/cmd/atlas",
"version",
),
expected: "atlas version - development\nhttps://github.com/ariga/atlas/releases/latest\n",
},
{
name: "release",
cmd: exec.Command("go", "run",
"-ldflags",
"-X ariga.io/atlas/cmd/atlas/internal/cmdapi.version=v1.2.3",
"ariga.io/atlas/cmd/atlas",
"version",
),
expected: "atlas version v1.2.3\nhttps://github.com/ariga/atlas/releases/tag/v1.2.3\n",
},
{
name: "canary",
cmd: exec.Command("go", "run",
"-ldflags",
"-X ariga.io/atlas/cmd/atlas/internal/cmdapi.version=v0.3.0-6539f2704b5d-canary",
"ariga.io/atlas/cmd/atlas",
"version",
),
expected: "atlas version v0.3.0-6539f2704b5d-canary\nhttps://github.com/ariga/atlas/releases/latest\n",
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
t.Setenv("ATLAS_NO_UPDATE_NOTIFIER", "true")
stdout := bytes.NewBuffer(nil)
tt.cmd.Stdout = stdout
require.NoError(t, tt.cmd.Run())
require.Equal(t, tt.expected, stdout.String())
})
}
}
atlas-0.7.2/cmd/atlas/internal/cmdapi/diff.go 0000664 0000000 0000000 00000006267 14314555116 0021023 0 ustar 00root root 0000000 0000000 // Copyright 2021-present The Atlas Authors. All rights reserved.
// This source code is licensed under the Apache 2.0 license found
// in the LICENSE file in the root directory of this source tree.
package cmdapi
import (
"fmt"
"strings"
"ariga.io/atlas/sql/schema"
"ariga.io/atlas/sql/sqlclient"
"github.com/spf13/cobra"
)
type diffCmdOpts struct {
fromURL string
toURL string
}
// newDiffCmd returns a new *cobra.Command that runs cmdDiffRun with the given flags and mux.
func newDiffCmd() *cobra.Command {
var opts diffCmdOpts
cmd := &cobra.Command{
Use: "diff",
Short: "Calculate and print the diff between two schemas.",
Long: `'atlas schema diff' connects to two given databases, inspects
them, calculates the difference in their schemas, and prints a plan of
SQL statements to migrate the "from" database to the schema of the "to" database.`,
Run: func(cmd *cobra.Command, args []string) {
cmdDiffRun(cmd, &opts)
},
}
cmd.Flags().StringVarP(&opts.fromURL, "from", "", "", "[driver://username:password@protocol(address)/dbname?param=value] select a database using the URL format")
cmd.Flags().StringVarP(&opts.toURL, "to", "", "", "[driver://username:password@protocol(address)/dbname?param=value] select a database using the URL format")
cobra.CheckErr(cmd.MarkFlagRequired("from"))
cobra.CheckErr(cmd.MarkFlagRequired("to"))
return cmd
}
func init() {
diffCmd := newDiffCmd()
schemaCmd.AddCommand(diffCmd)
}
// cmdDiffRun connects to the given databases, and prints an SQL plan to get from
// the "from" schema to the "to" schema.
func cmdDiffRun(cmd *cobra.Command, flags *diffCmdOpts) {
ctx := cmd.Context()
fromC, err := sqlclient.Open(cmd.Context(), flags.fromURL)
cobra.CheckErr(err)
defer fromC.Close()
toC, err := sqlclient.Open(cmd.Context(), flags.toURL)
cobra.CheckErr(err)
defer toC.Close()
fromS := fromC.URL.Schema
toS := toC.URL.Schema
var diff []schema.Change
switch {
case fromS == "" && toS == "":
// compare realm.
fromRealm, err := fromC.InspectRealm(ctx, nil)
cobra.CheckErr(err)
toRealm, err := toC.InspectRealm(ctx, nil)
cobra.CheckErr(err)
diff, err = toC.RealmDiff(fromRealm, toRealm)
cobra.CheckErr(err)
case fromS == "":
cobra.CheckErr(fmt.Errorf("cannot diff schema %q with a database connection", fromS))
case toS == "":
cobra.CheckErr(fmt.Errorf("cannot diff database connection with a schema %q", toS))
default:
// compare schemas.
fromSchema, err := fromC.InspectSchema(ctx, fromS, nil)
cobra.CheckErr(err)
toSchema, err := toC.InspectSchema(ctx, toS, nil)
cobra.CheckErr(err)
// SchemaDiff checks for name equality which is irrelevant in the case
// the user wants to compare their contents, if the names are different
// we reset them to allow the comparison.
if fromS != toS {
toSchema.Name = ""
fromSchema.Name = ""
}
diff, err = toC.SchemaDiff(fromSchema, toSchema)
cobra.CheckErr(err)
}
p, err := toC.PlanChanges(ctx, "plan", diff)
cobra.CheckErr(err)
if len(p.Changes) == 0 {
cmd.Println("Schemas are synced, no changes to be made.")
return
}
for _, c := range p.Changes {
if c.Comment != "" {
cmd.Println("--", strings.ToUpper(c.Comment[:1])+c.Comment[1:])
}
cmd.Println(c.Cmd)
}
}
atlas-0.7.2/cmd/atlas/internal/cmdapi/diff_test.go 0000664 0000000 0000000 00000003453 14314555116 0022054 0 ustar 00root root 0000000 0000000 // Copyright 2021-present The Atlas Authors. All rights reserved.
// This source code is licensed under the Apache 2.0 license found
// in the LICENSE file in the root directory of this source tree.
package cmdapi
import (
"bytes"
"context"
"database/sql"
"fmt"
"os"
"testing"
"ariga.io/atlas/sql/sqlite"
_ "github.com/mattn/go-sqlite3"
"github.com/spf13/cobra"
"github.com/stretchr/testify/require"
)
func TestDiffCmd_Diff(t *testing.T) {
from := openSQLite(t, "")
to := openSQLite(t, "create table t1 (id int);")
cmd := newDiffCmd()
s, err := runCmd(cmd, "schema", "diff", "--from", from, "--to", to)
require.NoError(t, err)
require.EqualValues(t, "-- Create \"t1\" table\nCREATE TABLE `t1` (`id` int NULL)\n", s)
}
func TestDiffCmd_Synced(t *testing.T) {
from := openSQLite(t, "")
to := openSQLite(t, "")
cmd := newDiffCmd()
s, err := runCmd(cmd, "schema", "diff", "--from", from, "--to", to)
require.NoError(t, err)
require.EqualValues(t, "Schemas are synced, no changes to be made.\n", s)
}
// openSQLite creates a sqlite db, seeds it with the seed query and returns the url to it.
func openSQLite(t *testing.T, seed string) string {
f, err := os.CreateTemp("", "sqlite.db")
require.NoError(t, err)
t.Cleanup(func() {
os.Remove(f.Name())
})
dsn := fmt.Sprintf("file:%s?cache=shared&_fk=1", f.Name())
db, err := sql.Open("sqlite3", dsn)
require.NoError(t, err)
t.Cleanup(func() {
db.Close()
})
drv, err := sqlite.Open(db)
require.NoError(t, err)
if len(seed) > 0 {
_, err := drv.ExecContext(context.Background(), seed)
require.NoError(t, err)
}
return fmt.Sprintf("sqlite://%s", dsn)
}
func runCmd(cmd *cobra.Command, args ...string) (string, error) {
var out bytes.Buffer
cmd.SetOut(&out)
cmd.SetErr(&out)
cmd.SetArgs(args)
err := cmd.Execute()
return out.String(), err
}
atlas-0.7.2/cmd/atlas/internal/cmdapi/migrate.go 0000664 0000000 0000000 00000145126 14314555116 0021541 0 ustar 00root root 0000000 0000000 // Copyright 2021-present The Atlas Authors. All rights reserved.
// This source code is licensed under the Apache 2.0 license found
// in the LICENSE file in the root directory of this source tree.
package cmdapi
import (
"context"
"database/sql"
"errors"
"fmt"
"io"
"io/fs"
"os"
"path/filepath"
"strconv"
"strings"
"text/template"
"time"
"ariga.io/atlas/cmd/atlas/internal/lint"
entmigrate "ariga.io/atlas/cmd/atlas/internal/migrate"
"ariga.io/atlas/cmd/atlas/internal/migrate/ent/revision"
"ariga.io/atlas/sql/migrate"
"ariga.io/atlas/sql/schema"
"ariga.io/atlas/sql/sqlcheck"
"ariga.io/atlas/sql/sqlclient"
"ariga.io/atlas/sql/sqltool"
"github.com/fatih/color"
"github.com/hashicorp/hcl/v2"
"github.com/hashicorp/hcl/v2/hclparse"
"github.com/hashicorp/hcl/v2/hclsyntax"
"github.com/spf13/cobra"
"github.com/spf13/pflag"
)
const (
migrateFlagURL = "url"
migrateFlagDevURL = "dev-url"
migrateFlagDir = "dir"
migrateFlagDirFormat = "dir-format"
migrateFlagLog = "log"
migrateFlagRevisionsSchema = "revisions-schema"
migrateFlagDryRun = "dry-run"
migrateFlagTo = "to"
migrateFlagFrom = "from"
migrateFlagSchema = "schema"
migrateLintLatest = "latest"
migrateLintGitDir = "git-dir"
migrateLintGitBase = "git-base"
migrateDiffQualifier = "qualifier"
migrateApplyAllowDirty = "allow-dirty"
migrateApplyBaselineVersion = "baseline"
migrateApplyTxMode = "tx-mode"
)
var (
// MigrateFlags are the flags used in MigrateCmd (and sub-commands).
MigrateFlags struct {
URL string
DevURL string
ToURLs []string
Schemas []string
DirURL string
DirFormat string
RevisionSchema string
Apply struct {
DryRun bool
LogFormat string
AllowDirty bool
FromVersion string
BaselineVersion string
TxMode string
}
Diff struct {
Qualifier string // optional table qualifier
}
Import struct {
FromURL string
ToURL string
}
Lint struct {
Format string // log formatting
Latest uint // latest N migration files
GitDir string // repository working dir
GitBase string // branch name to compare with
}
}
// MigrateCmd represents the migrate command. It wraps several other sub-commands.
MigrateCmd = &cobra.Command{
Use: "migrate",
Short: "Manage versioned migration files",
Long: "'atlas migrate' wraps several sub-commands for migration management.",
PersistentPreRunE: func(cmd *cobra.Command, _ []string) error {
if err := migrateFlagsFromEnv(cmd, nil); err != nil {
return err
}
dir, err := dir(false)
if err != nil {
return err
}
if err := migrate.Validate(dir); err != nil {
printChecksumErr(cmd.OutOrStderr())
cmd.SilenceUsage = true
return err
}
return nil
},
}
// MigrateApplyCmd represents the 'atlas migrate apply' subcommand.
MigrateApplyCmd = &cobra.Command{
Use: "apply [flags] [count]",
Short: "Applies pending migration files on the connected database.",
Long: `'atlas migrate apply' reads the migration state of the connected database and computes what migrations are pending.
It then attempts to apply the pending migration files in the correct order onto the database.
The first argument denotes the maximum number of migration files to apply.
As a safety measure 'atlas migrate apply' will abort with an error, if:
- the migration directory is not in sync with the 'atlas.sum' file
- the migration and database history do not match each other
If run with the "--dry-run" flag, atlas will not execute any SQL.`,
Example: ` atlas migrate apply -u mysql://user:pass@localhost:3306/dbname
atlas migrate apply --dir file:///path/to/migration/directory --url mysql://user:pass@localhost:3306/dbname 1
atlas migrate apply --env dev 1
atlas migrate apply --dry-run --env dev 1`,
Args: cobra.MaximumNArgs(1),
RunE: CmdMigrateApplyRun,
}
// MigrateDiffCmd represents the 'atlas migrate diff' subcommand.
MigrateDiffCmd = &cobra.Command{
Use: "diff [flags] [name]",
Short: "Compute the diff between the migration directory and a desired state and create a new migration file.",
Long: `'atlas migrate diff' uses the dev-database to re-run all migration files in the migration directory, compares
it to a given desired state and create a new migration file containing SQL statements to migrate the migration
directory state to the desired schema. The desired state can be another connected database or an HCL file.`,
Example: ` atlas migrate diff --dev-url mysql://user:pass@localhost:3306/dev --to file://atlas.hcl
atlas migrate diff --dev-url mysql://user:pass@localhost:3306/dev --to file://atlas.hcl add_users_table
atlas migrate diff --dev-url mysql://user:pass@localhost:3306/dev --to mysql://user:pass@localhost:3306/dbname
atlas migrate diff --env dev`,
Args: cobra.MaximumNArgs(1),
// If the migration directory does not exist on the validation attempt, this command will create it and
// consider the new migration directory "valid".
PersistentPreRunE: func(cmd *cobra.Command, _ []string) error {
if err := migrateFlagsFromEnv(cmd, nil); err != nil {
return err
}
dir, err := dir(true)
if err != nil {
return err
}
if err := migrate.Validate(dir); err != nil {
printChecksumErr(cmd.OutOrStderr())
cmd.SilenceUsage = true
return err
}
return nil
},
RunE: CmdMigrateDiffRun,
}
// MigrateHashCmd represents the 'atlas migrate hash' command.
MigrateHashCmd = &cobra.Command{
Use: "hash",
Short: "Hash (re-)creates an integrity hash file for the migration directory.",
Long: `'atlas migrate hash' computes the integrity hash sum of the migration directory and stores it in the atlas.sum file.
This command should be used whenever a manual change in the migration directory was made.`,
Example: ` atlas migrate hash`,
PersistentPreRunE: migrateFlagsFromEnv,
RunE: CmdMigrateHashRun,
}
// MigrateImportCmd represents the 'atlas migrate import' command.
MigrateImportCmd = &cobra.Command{
Use: "import",
Short: "Import a migration directory from another migration management tool to the Atlas format.",
Example: ` atlas migrate import --dir-format liquibase --from file:///path/to/source/directory --to file:///path/to/migration/directory`,
// Validate the source directory. Consider a directory with no sum file valid, since it might be an import
// from an existing project.
PersistentPreRunE: func(cmd *cobra.Command, _ []string) error {
if err := migrateFlagsFromEnv(cmd, nil); err != nil {
return err
}
MigrateFlags.DirURL = MigrateFlags.Import.FromURL
dir, err := dir(false)
if err != nil {
return err
}
if err := migrate.Validate(dir); err != nil && !errors.Is(err, migrate.ErrChecksumNotFound) {
printChecksumErr(cmd.OutOrStderr())
cmd.SilenceUsage = true
return err
}
return nil
},
RunE: CmdMigrateImportRun,
}
// MigrateNewCmd represents the 'atlas migrate new' command.
MigrateNewCmd = &cobra.Command{
Use: "new [name]",
Short: "Creates a new empty migration file in the migration directory.",
Long: `'atlas migrate new' creates a new migration according to the configured formatter without any statements in it.`,
Example: ` atlas migrate new my-new-migration`,
Args: cobra.MaximumNArgs(1),
RunE: CmdMigrateNewRun,
}
// MigrateSetCmd represents the 'atlas migrate set' command.
MigrateSetCmd = &cobra.Command{
Use: "set [flags]",
Short: "Set the current version of the migration history table.",
Long: `'atlas migrate set' edits the revision table to consider all migrations up to and including the given version
to be applied. This command is usually used after manually making changes to the managed database.`,
Example: ` atlas migrate set-revision 3 --url mysql://user:pass@localhost:3306/
atlas migrate set-revision 4 --env local
atlas migrate set-revision 1.2.4 --url mysql://user:pass@localhost:3306/my_db --revision-schema my_revisions`,
Args: cobra.ExactArgs(1),
RunE: CmdMigrateSetRun,
}
// MigrateStatusCmd represents the 'atlas migrate status' command.
MigrateStatusCmd = &cobra.Command{
Use: "status [flags]",
Short: "Get information about the current migration status.",
Long: `'atlas migrate status' reports information about the current status of a connected database compared to the migration directory.`,
Example: ` atlas migrate status --url mysql://user:pass@localhost:3306/
atlas migrate status --url mysql://user:pass@localhost:3306/ --dir file:///path/to/migration/directory`,
RunE: CmdMigrateStatusRun,
}
// MigrateValidateCmd represents the 'atlas migrate validate' command.
MigrateValidateCmd = &cobra.Command{
Use: "validate [flags]",
Short: "Validates the migration directories checksum and SQL statements.",
Long: `'atlas migrate validate' computes the integrity hash sum of the migration directory and compares it to the
atlas.sum file. If there is a mismatch it will be reported. If the --dev-url flag is given, the migration
files are executed on the connected database in order to validate SQL semantics.`,
Example: ` atlas migrate validate
atlas migrate validate --dir file:///path/to/migration/directory
atlas migrate validate --dir file:///path/to/migration/directory --dev-url mysql://user:pass@localhost:3306/dev
atlas migrate validate --env dev`,
RunE: CmdMigrateValidateRun,
}
// MigrateLintCmd represents the 'atlas migrate lint' command.
MigrateLintCmd = &cobra.Command{
Use: "lint",
Short: "Run analysis on the migration directory",
Example: ` atlas migrate lint --env dev
atlas migrate lint --dir file:///path/to/migration/directory --dev-url mysql://root:pass@localhost:3306 --latest 1
atlas migrate lint --dir file:///path/to/migration/directory --dev-url mysql://root:pass@localhost:3306 --git-base master
atlas migrate lint --dir file:///path/to/migration/directory --dev-url mysql://root:pass@localhost:3306 --log '{{ json .Files }}'`,
// Override the parent 'migrate' pre-run function to allow executing
// 'migrate lint' on directories that are not maintained by Atlas.
PersistentPreRunE: migrateFlagsFromEnv,
RunE: CmdMigrateLintRun,
}
)
func init() {
// Add sub-commands.
Root.AddCommand(MigrateCmd)
MigrateCmd.AddCommand(MigrateApplyCmd)
MigrateCmd.AddCommand(MigrateDiffCmd)
MigrateCmd.AddCommand(MigrateHashCmd)
MigrateCmd.AddCommand(MigrateNewCmd)
MigrateCmd.AddCommand(MigrateValidateCmd)
MigrateCmd.AddCommand(MigrateStatusCmd)
MigrateCmd.AddCommand(MigrateLintCmd)
MigrateCmd.AddCommand(MigrateImportCmd)
MigrateCmd.AddCommand(MigrateSetCmd)
// Reusable flags.
urlFlag := func(f *string, name, short string, set *pflag.FlagSet) {
set.StringVarP(f, name, short, "", "[driver://username:password@address/dbname?param=value] select a database using the URL format")
}
revisionsFlag := func(set *pflag.FlagSet) {
set.StringVarP(&MigrateFlags.RevisionSchema, migrateFlagRevisionsSchema, "", "", "schema name where the revisions table resides")
}
dirURLFlag := func(f *string, name, short string, set *pflag.FlagSet) {
set.StringVarP(f, name, short, "file://migrations", "select migration directory using URL format")
}
// Global flags.
dirURLFlag(&MigrateFlags.DirURL, migrateFlagDir, "", MigrateCmd.PersistentFlags())
MigrateCmd.PersistentFlags().StringSliceVarP(&MigrateFlags.Schemas, migrateFlagSchema, "", nil, "set schema names")
MigrateCmd.PersistentFlags().StringVarP(&MigrateFlags.DirFormat, migrateFlagDirFormat, "", formatAtlas, "set migration file format")
MigrateCmd.PersistentFlags().SortFlags = false
// Apply flags.
MigrateApplyCmd.Flags().StringVarP(&MigrateFlags.Apply.LogFormat, migrateFlagLog, "", logFormatTTY, "log format to use")
revisionsFlag(MigrateApplyCmd.Flags())
MigrateApplyCmd.Flags().BoolVarP(&MigrateFlags.Apply.DryRun, migrateFlagDryRun, "", false, "do not actually execute any SQL but show it on screen")
MigrateApplyCmd.Flags().StringVarP(&MigrateFlags.Apply.FromVersion, migrateFlagFrom, "", "", "calculate pending files from the given version (including it)")
MigrateApplyCmd.Flags().StringVarP(&MigrateFlags.Apply.BaselineVersion, migrateApplyBaselineVersion, "", "", "start the first migration after the given baseline version")
MigrateApplyCmd.Flags().StringVarP(&MigrateFlags.Apply.TxMode, migrateApplyTxMode, "", txModeFile, "set transaction mode [none, file, all]")
MigrateApplyCmd.Flags().BoolVarP(&MigrateFlags.Apply.AllowDirty, migrateApplyAllowDirty, "", false, "allow start working on a non-clean database")
urlFlag(&MigrateFlags.URL, migrateFlagURL, "u", MigrateApplyCmd.Flags())
MigrateApplyCmd.Flags().SortFlags = false
cobra.CheckErr(MigrateApplyCmd.MarkFlagRequired(migrateFlagURL))
MigrateApplyCmd.MarkFlagsMutuallyExclusive(migrateFlagFrom, migrateApplyBaselineVersion)
cobra.CheckErr(MigrateApplyCmd.Flags().MarkHidden(migrateFlagDirFormat))
cobra.CheckErr(MigrateApplyCmd.Flags().MarkHidden(migrateFlagSchema))
// Diff flags.
urlFlag(&MigrateFlags.DevURL, migrateFlagDevURL, "", MigrateDiffCmd.Flags())
MigrateDiffCmd.Flags().StringSliceVarP(&MigrateFlags.ToURLs, migrateFlagTo, "", nil, "[driver://username:password@address/dbname?param=value ...] select a desired state using the URL format")
MigrateDiffCmd.Flags().StringVarP(&MigrateFlags.Diff.Qualifier, migrateDiffQualifier, "", "", "qualify tables with custom qualifier when working on a single schema")
MigrateDiffCmd.Flags().SortFlags = false
cobra.CheckErr(MigrateDiffCmd.MarkFlagRequired(migrateFlagDevURL))
cobra.CheckErr(MigrateDiffCmd.MarkFlagRequired(migrateFlagTo))
// Import flags.
dirURLFlag(&MigrateFlags.Import.FromURL, migrateFlagFrom, "", MigrateImportCmd.Flags())
dirURLFlag(&MigrateFlags.Import.ToURL, migrateFlagTo, "", MigrateImportCmd.Flags())
MigrateImportCmd.Flags().SortFlags = false
// Validate flags.
urlFlag(&MigrateFlags.DevURL, migrateFlagDevURL, "", MigrateValidateCmd.Flags())
// Status flags.
urlFlag(&MigrateFlags.URL, migrateFlagURL, "u", MigrateStatusCmd.Flags())
revisionsFlag(MigrateStatusCmd.Flags())
// Set flags.
urlFlag(&MigrateFlags.URL, migrateFlagURL, "u", MigrateSetCmd.Flags())
// Hash flags.
MigrateHashCmd.Flags().Bool("force", false, "")
cobra.CheckErr(MigrateHashCmd.Flags().MarkDeprecated("force", "you can safely omit it."))
// Lint flags.
urlFlag(&MigrateFlags.DevURL, migrateFlagDevURL, "", MigrateLintCmd.Flags())
MigrateLintCmd.PersistentFlags().StringVarP(&MigrateFlags.Lint.Format, migrateFlagLog, "", "", "custom logging using a Go template")
MigrateLintCmd.PersistentFlags().UintVarP(&MigrateFlags.Lint.Latest, migrateLintLatest, "", 0, "run analysis on the latest N migration files")
MigrateLintCmd.PersistentFlags().StringVarP(&MigrateFlags.Lint.GitBase, migrateLintGitBase, "", "", "run analysis against the base Git branch")
MigrateLintCmd.PersistentFlags().StringVarP(&MigrateFlags.Lint.GitDir, migrateLintGitDir, "", ".", "path to the repository working directory")
cobra.CheckErr(MigrateLintCmd.MarkFlagRequired(migrateFlagDevURL))
receivesEnv(MigrateCmd)
}
const applyLockValue = "atlas_migrate_execute"
// CmdMigrateApplyRun is the command executed when running the CLI with 'migrate apply' args.
func CmdMigrateApplyRun(cmd *cobra.Command, args []string) error {
var (
n int
err error
)
if len(args) > 0 {
n, err = strconv.Atoi(args[0])
if err != nil {
return err
}
if n < 1 {
return fmt.Errorf("cannot apply '%d' migration files", n)
}
}
// Open the migration directory.
dir, err := dir(false)
if err != nil {
return err
}
// Open a client to the database.
c, err := sqlclient.Open(cmd.Context(), MigrateFlags.URL)
if err != nil {
return err
}
defer c.Close()
// Acquire a lock.
if l, ok := c.Driver.(schema.Locker); ok {
unlock, err := l.Lock(cmd.Context(), applyLockValue, 0)
if err != nil {
return fmt.Errorf("acquiring database lock: %w", err)
}
// If unlocking fails notify the user about it.
defer cobra.CheckErr(unlock())
}
if err := checkRevisionSchemaClarity(cmd, c); err != nil {
return err
}
// Get the correct log format and destination. Currently, only os.Stdout is supported.
l, err := logFormat(cmd.OutOrStdout())
if err != nil {
return err
}
var rrw migrate.RevisionReadWriter
rrw, err = entRevisions(cmd.Context(), c)
if err != nil {
return err
}
if err := rrw.(*entmigrate.EntRevisions).Migrate(cmd.Context()); err != nil {
return err
}
// Determine pending files and lock the database while working.
ex, err := migrate.NewExecutor(c.Driver, dir, rrw, executorOptions(l)...)
if err != nil {
return err
}
pending, err := ex.Pending(cmd.Context())
if err != nil && !errors.Is(err, migrate.ErrNoPendingFiles) {
return err
}
if errors.Is(err, migrate.ErrNoPendingFiles) {
cmd.Println("No migration files to execute")
return nil
}
if n > 0 {
// Cannot apply more than len(pending) files.
if n >= len(pending) {
n = len(pending)
}
pending = pending[:n]
}
revs, err := rrw.ReadRevisions(cmd.Context())
if err != nil {
return err
}
if err := migrate.LogIntro(l, revs, pending); err != nil {
return err
}
var (
mux = tx{c: c, rrw: rrw}
drv migrate.Driver
)
for _, f := range pending {
drv, rrw, err = mux.driver(cmd.Context())
if err != nil {
return err
}
ex, err := migrate.NewExecutor(drv, dir, rrw, executorOptions(l)...)
if err != nil {
return err
}
if err := mux.mayRollback(ex.Execute(cmd.Context(), f)); err != nil {
return err
}
if err := mux.mayCommit(); err != nil {
return err
}
}
if err := mux.commit(); err != nil {
return err
}
l.Log(migrate.LogDone{})
return mux.commit()
}
func checkRevisionSchemaClarity(cmd *cobra.Command, c *sqlclient.Client) error {
// The "old" default behavior for the revision schema location was to store the revision table in its own schema.
// Now, the table is saved in the connected schema, if any. To keep the backwards compatability, we now require
// for schema bound connections to have the schema-revision flag present if there is no revision table in the schema
// but the old default schema does have one.
if c.URL.Schema != "" && MigrateFlags.RevisionSchema == "" {
// If the schema does not contain a revision table, but we can find a table in the previous default schema,
// abort and tell the user to specify the intention.
opts := &schema.InspectOptions{Tables: []string{revision.Table}}
s, err := c.InspectSchema(cmd.Context(), "", opts)
var ok bool
switch {
case schema.IsNotExistError(err):
// If the schema does not exist, the table does not as well.
case err != nil:
return err
default:
// Connected schema does exist, check if the table does.
_, ok = s.Table(revision.Table)
}
if !ok { // Either schema or table does not exist.
// Check for the old default schema. If it does not exist, we have no problem.
s, err := c.InspectSchema(cmd.Context(), defaultRevisionSchema, opts)
switch {
case schema.IsNotExistError(err):
// Schema does not exist, we can proceed.
case err != nil:
return err
default:
if _, ok := s.Table(revision.Table); ok {
fmt.Fprintf(cmd.OutOrStderr(),
`We couldn't find a revision table in the connected schema but found one in
the schema 'atlas_schema_revisions' and cannot determine the desired behavior.
As a safety guard, we require you to specify whether to use the existing
table in 'atlas_schema_revisions' or create a new one in the connected schema
by providing the '--revisions-schema' flag or deleting the 'atlas_schema_revisions'
schema if it is unused.
`)
cmd.SilenceUsage = true
cmd.SilenceErrors = true
return errors.New("ambiguous revision table")
}
}
}
}
return nil
}
func entRevisions(ctx context.Context, c *sqlclient.Client) (*entmigrate.EntRevisions, error) {
return entmigrate.NewEntRevisions(ctx, c, entmigrate.WithSchema(revisionSchemaName(c)))
}
// defaultRevisionSchema is the default schema for storing revisions table.
const defaultRevisionSchema = "atlas_schema_revisions"
func revisionSchemaName(c *sqlclient.Client) string {
switch {
case MigrateFlags.RevisionSchema != "":
return MigrateFlags.RevisionSchema
case c.URL.Schema != "":
return c.URL.Schema
default:
return defaultRevisionSchema
}
}
// tx handles wrapping migration execution in transactions.
type tx struct {
c *sqlclient.Client
tx *sqlclient.TxClient
rrw migrate.RevisionReadWriter
}
// driver returns the migrate.Driver to use to execute migration statements.
func (tx *tx) driver(ctx context.Context) (migrate.Driver, migrate.RevisionReadWriter, error) {
if MigrateFlags.Apply.DryRun {
// If the --dry-run flag is given we don't want to execute any statements on the database.
return &dryRunDriver{tx.c.Driver}, &dryRunRevisions{tx.rrw}, nil
}
switch MigrateFlags.Apply.TxMode {
case txModeNone:
return tx.c.Driver, tx.rrw, nil
case txModeFile:
// In file-mode, this function is called each time a new file is executed. Open a transaction.
if tx.tx != nil {
return nil, nil, errors.New("unexpected active transaction")
}
var err error
tx.tx, err = tx.c.Tx(ctx, nil)
if err != nil {
return nil, nil, err
}
tx.rrw, err = entRevisions(ctx, tx.tx.Client)
if err != nil {
return nil, nil, err
}
return tx.tx.Driver, tx.rrw, nil
case txModeAll:
// In file-mode, this function is called each time a new file is executed. Since we wrap all files into one
// huge transaction, if there already is an opened one, use that.
if tx.tx == nil {
var err error
tx.tx, err = tx.c.Tx(ctx, nil)
if err != nil {
return nil, nil, err
}
tx.rrw, err = entRevisions(ctx, tx.tx.Client)
if err != nil {
return nil, nil, err
}
}
return tx.tx.Driver, tx.rrw, nil
default:
return nil, nil, fmt.Errorf("unknown tx-mode %q", MigrateFlags.Apply.TxMode)
}
}
// mayRollback may roll back a transaction depending on the given transaction mode.
func (tx *tx) mayRollback(err error) error {
if tx.tx != nil && err != nil {
if err2 := tx.tx.Rollback(); err2 != nil {
err = fmt.Errorf("%v: %w", err2, err)
}
}
return err
}
// mayCommit may commit a transaction depending on the given transaction mode.
func (tx *tx) mayCommit() error {
// Only commit if each file is wrapped in a transaction.
if !MigrateFlags.Apply.DryRun && MigrateFlags.Apply.TxMode == txModeFile {
return tx.commit()
}
return nil
}
// commit the transaction, if one is active.
func (tx *tx) commit() error {
if tx.tx == nil {
return nil
}
defer func() { tx.tx = nil }()
return tx.tx.Commit()
}
func executorOptions(l migrate.Logger) []migrate.ExecutorOption {
opts := []migrate.ExecutorOption{
migrate.WithLogger(l),
migrate.WithOperatorVersion(operatorVersion()),
}
if MigrateFlags.Apply.AllowDirty {
opts = append(opts, migrate.WithAllowDirty(true))
}
if v := MigrateFlags.Apply.BaselineVersion; v != "" {
opts = append(opts, migrate.WithBaselineVersion(v))
}
if v := MigrateFlags.Apply.FromVersion; v != "" {
opts = append(opts, migrate.WithFromVersion(v))
}
return opts
}
func operatorVersion() string {
v, _ := parse(version)
return "Atlas CLI - " + v
}
// CmdMigrateDiffRun is the command executed when running the CLI with 'migrate diff' args.
func CmdMigrateDiffRun(cmd *cobra.Command, args []string) error {
// Open a dev driver.
dev, err := sqlclient.Open(cmd.Context(), MigrateFlags.DevURL)
if err != nil {
return err
}
defer dev.Close()
// Acquire a lock.
if l, ok := dev.Driver.(schema.Locker); ok {
unlock, err := l.Lock(cmd.Context(), "atlas_migrate_diff", 0)
if err != nil {
return fmt.Errorf("acquiring database lock: %w", err)
}
// If unlocking fails notify the user about it.
defer cobra.CheckErr(unlock())
}
// Open the migration directory.
dir, err := dir(false)
if err != nil {
return err
}
// Get a state reader for the desired state.
desired, err := to(cmd.Context(), dev)
if err != nil {
return err
}
defer desired.Close()
f, err := formatter()
if err != nil {
return err
}
opts := []migrate.PlannerOption{migrate.PlanFormat(f)}
if dev.URL.Schema != "" {
// Disable tables qualifier in schema-mode.
opts = append(opts, migrate.PlanWithSchemaQualifier(MigrateFlags.Diff.Qualifier))
}
// Plan the changes and create a new migration file.
pl := migrate.NewPlanner(dev.Driver, dir, opts...)
var name string
if len(args) > 0 {
name = args[0]
}
plan, err := func() (*migrate.Plan, error) {
if dev.URL.Schema != "" {
return pl.PlanSchema(cmd.Context(), name, desired.StateReader)
}
return pl.Plan(cmd.Context(), name, desired.StateReader)
}()
var cerr migrate.NotCleanError
switch {
case errors.Is(err, migrate.ErrNoPlan):
cmd.Println("The migration directory is synced with the desired state, no changes to be made")
return nil
case errors.As(err, &cerr) && dev.URL.Schema == "" && desired.Schema != "":
return fmt.Errorf("dev database is not clean (%s). Add a schema to the URL to limit the scope of the connection", cerr.Reason)
case err != nil:
return err
default:
// Write the plan to a new file.
return pl.WritePlan(plan)
}
}
// CmdMigrateHashRun is the command executed when running the CLI with 'migrate hash' args.
func CmdMigrateHashRun(*cobra.Command, []string) error {
dir, err := dir(false)
if err != nil {
return err
}
sum, err := dir.Checksum()
if err != nil {
return err
}
return migrate.WriteSumFile(dir, sum)
}
// CmdMigrateImportRun is the command executed when running the CLI with 'migrate import' args.
func CmdMigrateImportRun(cmd *cobra.Command, _ []string) error {
if MigrateFlags.DirFormat == formatAtlas {
return fmt.Errorf("cannot import a migration directory already in %q format", formatAtlas)
}
MigrateFlags.DirURL = MigrateFlags.Import.FromURL
src, err := dir(false)
if err != nil {
return err
}
MigrateFlags.DirFormat = formatAtlas
MigrateFlags.DirURL = MigrateFlags.Import.ToURL
trgt, err := dir(true)
if err != nil {
return err
}
// Target must be empty.
ff, err := trgt.Files()
switch {
case err != nil:
return err
case len(ff) != 0:
return errors.New("target migration directory must be empty")
}
ff, err = src.Files()
switch {
case err != nil:
return err
case len(ff) == 0:
fmt.Fprint(cmd.OutOrStderr(), "nothing to import")
cmd.SilenceUsage = true
return nil
}
// Fix version numbers for Flyway repeatable migrations.
if _, ok := src.(*sqltool.FlywayDir); ok {
sqltool.SetRepeatableVersion(ff)
}
// Extract the statements for each of the migration files, add them to a plan to format with the
// migrate.DefaultFormatter.
for _, f := range ff {
stmts, err := f.StmtDecls()
if err != nil {
return err
}
plan := &migrate.Plan{
Version: f.Version(),
Name: f.Desc(),
Changes: make([]*migrate.Change, len(stmts)),
}
var buf strings.Builder
for i, s := range stmts {
for _, c := range s.Comments {
buf.WriteString(c)
if !strings.HasSuffix(c, "\n") {
buf.WriteString("\n")
}
}
buf.WriteString(strings.TrimSuffix(s.Text, ";"))
plan.Changes[i] = &migrate.Change{Cmd: buf.String()}
buf.Reset()
}
files, err := migrate.DefaultFormatter.Format(plan)
if err != nil {
return err
}
for _, f := range files {
if err := trgt.WriteFile(f.Name(), f.Bytes()); err != nil {
return err
}
}
}
sum, err := trgt.Checksum()
if err != nil {
return err
}
return migrate.WriteSumFile(trgt, sum)
}
// CmdMigrateNewRun is the command executed when running the CLI with 'migrate new' args.
func CmdMigrateNewRun(_ *cobra.Command, args []string) error {
dir, err := dir(true)
if err != nil {
return err
}
f, err := formatter()
if err != nil {
return err
}
var name string
if len(args) > 0 {
name = args[0]
}
return migrate.NewPlanner(nil, dir, migrate.PlanFormat(f)).WritePlan(&migrate.Plan{Name: name})
}
// CmdMigrateSetRun is the command executed when running the CLI with 'migrate set' args.
func CmdMigrateSetRun(cmd *cobra.Command, args []string) error {
dir, err := dir(false)
if err != nil {
return err
}
avail, err := dir.Files()
if err != nil {
return err
}
// Check if the target version does exist in the migration directory.
if idx := migrate.FilesLastIndex(avail, func(f migrate.File) bool {
return f.Version() == args[0]
}); idx == -1 {
return fmt.Errorf("migration with version %q not found", args[0])
}
client, err := sqlclient.Open(cmd.Context(), MigrateFlags.URL)
if err != nil {
return err
}
defer client.Close()
// Acquire a lock.
if l, ok := client.Driver.(schema.Locker); ok {
unlock, err := l.Lock(cmd.Context(), applyLockValue, 0)
if err != nil {
return fmt.Errorf("acquiring database lock: %w", err)
}
// If unlocking fails notify the user about it.
defer cobra.CheckErr(unlock())
}
if err := checkRevisionSchemaClarity(cmd, client); err != nil {
return err
}
// Ensure revision table exists.
rrw, err := entRevisions(cmd.Context(), client)
if err != nil {
return err
}
if err := rrw.Migrate(cmd.Context()); err != nil {
return err
}
// Wrap manipulation in a transaction.
tx, err := client.Tx(cmd.Context(), nil)
if err != nil {
return err
}
rrw, err = entRevisions(cmd.Context(), tx.Client)
if err != nil {
return err
}
revs, err := rrw.ReadRevisions(cmd.Context())
if err != nil {
return err
}
if err := func() error {
for _, r := range revs {
// Check all existing revisions and ensure they precede the given version. If we encounter a partially
// applied revision, or one with errors, mark them "fixed".
switch {
// remove revision to keep linear history
case r.Version > args[0]:
if err := rrw.DeleteRevision(cmd.Context(), r.Version); err != nil {
return err
}
// keep, but if with error mark "fixed"
case r.Version == args[0] && (r.Error != "" || r.Total != r.Applied):
r.Type = migrate.RevisionTypeExecute | migrate.RevisionTypeResolved
if err := rrw.WriteRevision(cmd.Context(), r); err != nil {
return err
}
}
}
revs, err = rrw.ReadRevisions(cmd.Context())
if err != nil {
return err
}
// If the target version succeeds the last revision, mark
// migrations applied, until we reach the target version.
var pending []migrate.File
switch {
case len(revs) == 0:
// Take every file until we reach target version.
for _, f := range avail {
if f.Version() > args[0] {
break
}
pending = append(pending, f)
}
case args[0] > revs[len(revs)-1].Version:
loop:
// Take every file succeeding the last revision until we reach target version.
for _, f := range avail {
switch {
case f.Version() <= revs[len(revs)-1].Version:
// Migration precedes last revision.
case f.Version() > args[0]:
// Migration succeeds target revision.
break loop
default: // between last revision and target
pending = append(pending, f)
}
}
}
// Mark every pending file as applied.
sum, err := dir.Checksum()
if err != nil {
return err
}
for _, f := range pending {
h, err := sum.SumByName(f.Name())
if err != nil {
return err
}
if err := rrw.WriteRevision(cmd.Context(), &migrate.Revision{
Version: f.Version(),
Description: f.Desc(),
Type: migrate.RevisionTypeResolved,
ExecutedAt: time.Now(),
Hash: h,
OperatorVersion: operatorVersion(),
}); err != nil {
return err
}
}
return nil
}(); err != nil {
if err2 := tx.Rollback(); err2 != nil {
err = fmt.Errorf("%v: %w", err2, err)
}
return err
}
return tx.Commit()
}
// CmdMigrateStatusRun is the command executed when running the CLI with 'migrate status' args.
func CmdMigrateStatusRun(cmd *cobra.Command, _ []string) error {
// Open the migration directory.
dir, err := dir(false)
if err != nil {
return err
}
avail, err := dir.Files()
if err != nil {
return err
}
// Open a client to the database.
client, err := sqlclient.Open(cmd.Context(), MigrateFlags.URL)
if err != nil {
return err
}
defer client.Close()
if err := checkRevisionSchemaClarity(cmd, client); err != nil {
return err
}
// Inspect schema and check if the table does already exist.
s, err := client.InspectSchema(
cmd.Context(),
revisionSchemaName(client),
&schema.InspectOptions{Tables: []string{revision.Table}},
)
switch {
case err != nil && !schema.IsNotExistError(err):
return err
case schema.IsNotExistError(err):
return statusPrint(cmd.OutOrStdout(), avail, avail, nil)
}
if _, ok := s.Table(revision.Table); !ok {
// Table does not exist.
return statusPrint(cmd.OutOrStdout(), avail, avail, nil)
}
// Currently, only in DB revisions are supported.
rrw, err := entRevisions(cmd.Context(), client)
if err != nil {
return err
}
// Executor can give us insights on the revision state.
ex, err := migrate.NewExecutor(client.Driver, dir, rrw)
if err != nil {
return err
}
pending, err := ex.Pending(cmd.Context())
if err != nil && !errors.Is(err, migrate.ErrNoPendingFiles) {
return err
}
revs, err := rrw.ReadRevisions(cmd.Context())
if err != nil {
return err
}
return statusPrint(cmd.OutOrStdout(), avail, pending, revs)
}
func statusPrint(out io.Writer, avail, pending []migrate.File, revs []*migrate.Revision) (err error) {
var (
cur, next, state string
applied = avail[: len(avail)-len(pending) : len(avail)-len(pending)]
partial = len(revs) != 0 && revs[len(revs)-1].Applied < revs[len(revs)-1].Total
)
switch len(pending) {
case len(avail):
cur = "No version applied yet"
default:
cur = cyan(applied[len(applied)-1].Version())
// If the last pending version is partially applied, tell so.
if partial {
cur += fmt.Sprintf(" (%d statements applied)", revs[len(revs)-1].Applied)
}
}
if len(pending) == 0 {
state = green("OK")
next = "Already at latest version"
} else {
state = yellow("PENDING")
next = cyan(pending[0].Version())
if partial {
next += fmt.Sprintf(" (%d statements left)", revs[len(revs)-1].Total-revs[len(revs)-1].Applied)
}
}
exec := cyan(strconv.Itoa(len(applied)))
if partial {
exec += " + 1 partially"
}
c := cyan
if len(pending) == 0 {
c = green
}
fmt.Fprintf(out, "Migration Status: %s\n", state)
fmt.Fprintf(out, "%s%s Current Version: %s\n", indent2, dash, cur)
fmt.Fprintf(out, "%s%s Next Version: %s\n", indent2, dash, next)
fmt.Fprintf(out, "%s%s Executed Files: %s\n", indent2, dash, exec)
fmt.Fprintf(out, "%s%s Pending Files: %s", indent2, dash, c(strconv.Itoa(len(pending))))
if partial {
fmt.Fprintf(out, " (partially)")
}
fmt.Fprintf(out, "\n")
return nil
}
// CmdMigrateValidateRun is the command executed when running the CLI with 'migrate validate' args.
func CmdMigrateValidateRun(cmd *cobra.Command, _ []string) error {
// Validating the integrity is done by the PersistentPreRun already.
if MigrateFlags.DevURL == "" {
// If there is no --dev-url given do not attempt to replay the migration directory.
return nil
}
// Open a client for the dev-db.
dev, err := sqlclient.Open(cmd.Context(), MigrateFlags.DevURL)
if err != nil {
return err
}
defer dev.Close()
// Currently, only our own migration file format is supported.
dir, err := dir(false)
if err != nil {
return err
}
ex, err := migrate.NewExecutor(dev.Driver, dir, migrate.NopRevisionReadWriter{})
if err != nil {
return err
}
if _, err := ex.Replay(cmd.Context(), func() migrate.StateReader {
if dev.URL.Schema != "" {
return migrate.SchemaConn(dev, "", nil)
}
return migrate.RealmConn(dev, nil)
}()); err != nil && !errors.Is(err, migrate.ErrNoPendingFiles) {
return fmt.Errorf("replaying the migration directory: %w", err)
}
return nil
}
// CmdMigrateLintRun is the command executed when running the CLI with 'migrate lint' args.
func CmdMigrateLintRun(cmd *cobra.Command, _ []string) error {
dev, err := sqlclient.Open(cmd.Context(), MigrateFlags.DevURL)
if err != nil {
return err
}
defer dev.Close()
dir, err := dir(false)
if err != nil {
return err
}
var detect lint.ChangeDetector
switch {
case MigrateFlags.Lint.Latest == 0 && MigrateFlags.Lint.GitBase == "":
return fmt.Errorf("--%s or --%s is required", migrateLintLatest, migrateLintGitBase)
case MigrateFlags.Lint.Latest > 0 && MigrateFlags.Lint.GitBase != "":
return fmt.Errorf("--%s and --%s are mutually exclusive", migrateLintLatest, migrateLintGitBase)
case MigrateFlags.Lint.Latest > 0:
detect = lint.LatestChanges(dir, int(MigrateFlags.Lint.Latest))
case MigrateFlags.Lint.GitBase != "":
detect, err = lint.NewGitChangeDetector(
dir,
lint.WithWorkDir(MigrateFlags.Lint.GitDir),
lint.WithBase(MigrateFlags.Lint.GitBase),
lint.WithMigrationsPath(dir.(interface{ Path() string }).Path()),
)
if err != nil {
return err
}
}
format := lint.DefaultTemplate
if f := MigrateFlags.Lint.Format; f != "" {
format, err = template.New("format").Funcs(lint.TemplateFuncs).Parse(f)
if err != nil {
return fmt.Errorf("parse log format: %w", err)
}
}
env, err := selectEnv(GlobalFlags.SelectedEnv)
if err != nil {
return err
}
az, err := sqlcheck.AnalyzerFor(dev.Name, env.Lint.Remain())
if err != nil {
return err
}
r := &lint.Runner{
Dev: dev,
Dir: dir,
ChangeDetector: detect,
ReportWriter: &lint.TemplateWriter{
T: format,
W: cmd.OutOrStdout(),
},
Analyzers: az,
}
err = r.Run(cmd.Context())
// Print the error in case it was not printed before.
cmd.SilenceErrors = errors.As(err, &lint.SilentError{})
return err
}
const (
txModeNone = "none"
txModeAll = "all"
txModeFile = "file"
)
func printChecksumErr(out io.Writer) {
fmt.Fprintf(out, `You have a checksum error in your migration directory.
This happens if you manually create or edit a migration file.
Please check your migration files and run
'atlas migrate hash'
to re-hash the contents and resolve the error
`)
}
// dir returns a migrate.Dir to use as migration directory. For now only local directories are supported.
func dir(create bool) (migrate.Dir, error) {
parts := strings.SplitN(MigrateFlags.DirURL, "://", 2)
if len(parts) != 2 {
return nil, fmt.Errorf("invalid dir url %q", MigrateFlags.DirURL)
}
if parts[0] != "file" {
return nil, fmt.Errorf("unsupported driver %q", parts[0])
}
f := func() (migrate.Dir, error) { return migrate.NewLocalDir(parts[1]) }
switch MigrateFlags.DirFormat {
case formatAtlas:
case formatGolangMigrate:
f = func() (migrate.Dir, error) { return sqltool.NewGolangMigrateDir(parts[1]) }
case formatGoose:
f = func() (migrate.Dir, error) { return sqltool.NewGooseDir(parts[1]) }
case formatFlyway:
f = func() (migrate.Dir, error) { return sqltool.NewFlywayDir(parts[1]) }
case formatLiquibase:
f = func() (migrate.Dir, error) { return sqltool.NewLiquibaseDir(parts[1]) }
case formatDBMate:
f = func() (migrate.Dir, error) { return sqltool.NewDBMateDir(parts[1]) }
default:
return nil, fmt.Errorf("unknown dir format %q", MigrateFlags.DirFormat)
}
d, err := f()
if create && errors.Is(err, fs.ErrNotExist) {
if err := os.MkdirAll(parts[1], 0755); err != nil {
return nil, err
}
d, err = f()
}
return d, err
}
type target struct {
migrate.StateReader // desired state.
io.Closer // optional close function.
Schema string // in case we work on a single schema.
}
// to returns a migrate.StateReader for the given to flag.
func to(ctx context.Context, dev *sqlclient.Client) (*target, error) {
scheme, err := selectScheme(MigrateFlags.ToURLs)
if err != nil {
return nil, err
}
schemas := MigrateFlags.Schemas
switch scheme {
case "file": // hcl file
realm := &schema.Realm{}
paths := make([]string, 0, len(MigrateFlags.ToURLs))
for _, u := range MigrateFlags.ToURLs {
paths = append(paths, strings.TrimPrefix(u, "file://"))
}
parsed, err := parseHCLPaths(paths...)
if err != nil {
return nil, err
}
if err := dev.Eval(parsed, realm, nil); err != nil {
return nil, err
}
if len(schemas) > 0 {
// Validate all schemas in file were selected by user.
sm := make(map[string]bool, len(schemas))
for _, s := range schemas {
sm[s] = true
}
for _, s := range realm.Schemas {
if !sm[s.Name] {
return nil, fmt.Errorf("schema %q from paths %q is not requested (all schemas in HCL must be requested)", s.Name, paths)
}
}
}
// In case the dev connection is bound to a specific schema, we require the
// desired schema to contain only one schema. Thus, executing diff will be
// done on the content of these two schema and not the whole realm.
if dev.URL.Schema != "" && len(realm.Schemas) > 1 {
return nil, fmt.Errorf("cannot use HCL with more than 1 schema when dev-url is limited to schema %q", dev.URL.Schema)
}
if norm, ok := dev.Driver.(schema.Normalizer); ok && len(realm.Schemas) > 0 {
realm, err = norm.NormalizeRealm(ctx, realm)
if err != nil {
return nil, err
}
}
t := &target{StateReader: migrate.Realm(realm), Closer: io.NopCloser(nil)}
if len(realm.Schemas) == 1 {
t.Schema = realm.Schemas[0].Name
}
return t, nil
default: // database connection
client, err := sqlclient.Open(ctx, MigrateFlags.ToURLs[0])
if err != nil {
return nil, err
}
t := &target{Closer: client}
switch s := client.URL.Schema; {
// Connection to a specific schema.
case s != "":
if len(schemas) > 1 || len(schemas) == 1 && schemas[0] != s {
return nil, fmt.Errorf("cannot specify schemas with a schema connection to %q", s)
}
t.Schema = s
t.StateReader = migrate.SchemaConn(client, s, &schema.InspectOptions{})
// A single schema is selected.
case len(schemas) == 1:
t.Schema = schemas[0]
t.StateReader = migrate.SchemaConn(client, schemas[0], &schema.InspectOptions{})
// Multiple or all schemas.
default:
// In case the dev connection is limited to a single schema,
// but we compare it to entire database.
if dev.URL.Schema != "" {
return nil, fmt.Errorf("cannot use database-url without a schema when dev-url is limited to %q", dev.URL.Schema)
}
t.StateReader = migrate.RealmConn(client, &schema.InspectRealmOption{Schemas: schemas})
}
return t, nil
}
}
// selectScheme validates the scheme of the provided to urls and returns the selected
// url scheme. Currently, all URLs must be of the same scheme, and only multiple
// "file://" URLs are allowed.
func selectScheme(urls []string) (string, error) {
var scheme string
if len(urls) == 0 {
return "", errors.New("at least one --to url is required")
}
for _, url := range urls {
parts := strings.SplitN(url, "://", 2)
switch current := parts[0]; {
case scheme == "":
scheme = current
case scheme != current:
return "", fmt.Errorf("got mixed --to url schemes: %q and %q, the desired state must be provided from a single kind of source", scheme, current)
case current != "file":
return "", fmt.Errorf("got multiple --to urls of scheme %q, only multiple 'file://' urls are supported", current)
}
}
return scheme, nil
}
// parseHCLPaths parses the HCL files in the given paths. If a path represents a directory,
// its direct descendants will be considered, skipping any subdirectories. If a project file
// is present in the input paths, an error is returned.
func parseHCLPaths(paths ...string) (*hclparse.Parser, error) {
p := hclparse.NewParser()
for _, path := range paths {
switch stat, err := os.Stat(path); {
case err != nil:
return nil, err
case stat.IsDir():
dir, err := os.ReadDir(path)
if err != nil {
return nil, err
}
for _, f := range dir {
// Skip nested dirs.
if f.IsDir() {
continue
}
if err := mayParse(p, filepath.Join(path, f.Name())); err != nil {
return nil, err
}
}
default:
if err := mayParse(p, path); err != nil {
return nil, err
}
}
}
if len(p.Files()) == 0 {
return nil, fmt.Errorf("no schema files found in: %s", paths)
}
return p, nil
}
// mayParse will parse the file in path if it is an HCL file. If the file is an Atlas
// project file an error is returned.
func mayParse(p *hclparse.Parser, path string) error {
if n := filepath.Base(path); filepath.Ext(n) != ".hcl" {
return nil
}
switch f, diag := p.ParseHCLFile(path); {
case diag.HasErrors():
return diag
case isProjectFile(f):
return fmt.Errorf("cannot parse project file %q as a schema file", path)
default:
return nil
}
}
func isProjectFile(f *hcl.File) bool {
for _, blk := range f.Body.(*hclsyntax.Body).Blocks {
if blk.Type == "env" {
return true
}
}
return false
}
const (
formatAtlas = "atlas"
formatGolangMigrate = "golang-migrate"
formatGoose = "goose"
formatFlyway = "flyway"
formatLiquibase = "liquibase"
formatDBMate = "dbmate"
)
func formatter() (migrate.Formatter, error) {
switch MigrateFlags.DirFormat {
case formatAtlas:
return migrate.DefaultFormatter, nil
case formatGolangMigrate:
return sqltool.GolangMigrateFormatter, nil
case formatGoose:
return sqltool.GooseFormatter, nil
case formatFlyway:
return sqltool.FlywayFormatter, nil
case formatLiquibase:
return sqltool.LiquibaseFormatter, nil
case formatDBMate:
return sqltool.DBMateFormatter, nil
default:
return nil, fmt.Errorf("unknown format %q", MigrateFlags.DirFormat)
}
}
const logFormatTTY = "tty"
// LogTTY is a migrate.Logger that pretty prints execution progress.
// If the connected out is not a tty, it will fall back to a non-colorful output.
type LogTTY struct {
out io.Writer
start time.Time
fileStart time.Time
fileCounter int
stmtCounter int
}
var (
cyan = color.CyanString
green = color.HiGreenString
red = color.HiRedString
redBgWhiteFg = color.New(color.FgHiWhite, color.BgHiRed).SprintFunc()
yellow = color.YellowString
dash = yellow("--")
arr = cyan("->")
indent2 = " "
indent4 = indent2 + indent2
)
// Log implements the migrate.Logger interface.
func (l *LogTTY) Log(e migrate.LogEntry) {
switch e := e.(type) {
case migrate.LogExecution:
l.start = time.Now()
fmt.Fprintf(l.out, "Migrating to version %v", cyan(e.To))
if e.From != "" {
fmt.Fprintf(l.out, " from %v", cyan(e.From))
}
fmt.Fprintf(l.out, " (%d migrations in total):\n", len(e.Files))
case migrate.LogFile:
l.fileCounter++
if !l.fileStart.IsZero() {
l.reportFileEnd()
}
l.fileStart = time.Now()
fmt.Fprintf(l.out, "\n%s%v migrating version %v", indent2, dash, cyan(e.Version))
if e.Skip > 0 {
fmt.Fprintf(l.out, " (partially applied - skipping %s statements)", yellow("%d", e.Skip))
}
fmt.Fprint(l.out, "\n")
case migrate.LogStmt:
l.stmtCounter++
fmt.Fprintf(l.out, "%s%v %s\n", indent4, arr, e.SQL)
case migrate.LogDone:
l.reportFileEnd()
fmt.Fprintf(l.out, "\n%s%v\n", indent2, cyan(strings.Repeat("-", 25)))
fmt.Fprintf(l.out, "%s%v %v\n", indent2, dash, time.Since(l.start))
fmt.Fprintf(l.out, "%s%v %v migrations\n", indent2, dash, l.fileCounter)
fmt.Fprintf(l.out, "%s%v %v sql statements\n", indent2, dash, l.stmtCounter)
case migrate.LogError:
fmt.Fprintf(l.out, "%s %s\n", indent4, redBgWhiteFg(e.Error.Error()))
fmt.Fprintf(l.out, "\n%s%v\n", indent2, cyan(strings.Repeat("-", 25)))
fmt.Fprintf(l.out, "%s%v %v\n", indent2, dash, time.Since(l.start))
fmt.Fprintf(l.out, "%s%v %v migrations ok (%s)\n", indent2, dash, zero(l.fileCounter-1), red("1 with errors"))
fmt.Fprintf(l.out, "%s%v %v sql statements ok (%s)\n", indent2, dash, zero(l.stmtCounter-1), red("1 with errors"))
fmt.Fprintf(l.out, "\n%s\n%v\n\n", red("Error: Execution had errors:"), redBgWhiteFg(e.Error.Error()))
default:
fmt.Fprintf(l.out, "%v", e)
}
}
func (l *LogTTY) reportFileEnd() {
fmt.Fprintf(l.out, "%s%v ok (%v)\n", indent2, dash, yellow("%s", time.Since(l.fileStart)))
}
func zero(v int) int {
if v < 0 {
return 0
}
return v
}
func logFormat(out io.Writer) (migrate.Logger, error) {
switch l := MigrateFlags.Apply.LogFormat; l {
case logFormatTTY:
return &LogTTY{out: out}, nil
default:
return nil, fmt.Errorf("unknown log-format %q", l)
}
}
func migrateFlagsFromEnv(cmd *cobra.Command, _ []string) error {
activeEnv, err := selectEnv(GlobalFlags.SelectedEnv)
if err != nil {
return err
}
if err := inputValsFromEnv(cmd); err != nil {
return err
}
if err := maySetFlag(cmd, migrateFlagDevURL, activeEnv.DevURL); err != nil {
return err
}
if err := maySetFlag(cmd, migrateFlagDirFormat, activeEnv.Migration.Format); err != nil {
return err
}
switch cmd.Name() {
case "lint":
if err := maySetFlag(cmd, migrateFlagLog, activeEnv.Lint.Log); err != nil {
return err
}
if err := maySetFlag(cmd, migrateLintLatest, strconv.Itoa(activeEnv.Lint.Latest)); err != nil {
return err
}
if err := maySetFlag(cmd, migrateLintGitDir, activeEnv.Lint.Git.Dir); err != nil {
return err
}
if err := maySetFlag(cmd, migrateLintGitBase, activeEnv.Lint.Git.Base); err != nil {
return err
}
default:
if err := maySetFlag(cmd, migrateFlagURL, activeEnv.URL); err != nil {
return err
}
if err := maySetFlag(cmd, migrateFlagRevisionsSchema, activeEnv.Migration.RevisionsSchema); err != nil {
return err
}
}
// Transform "src" to a URL.
srcs, err := activeEnv.Sources()
if err != nil {
return err
}
for i, s := range srcs {
if s, err = filepath.Abs(s); err != nil {
return fmt.Errorf("finding abs path to source: %q: %w", s, err)
}
srcs[i] = "file://" + s
}
if err := maySetFlag(cmd, migrateFlagTo, strings.Join(srcs, ",")); err != nil {
return err
}
if s := "[" + strings.Join(activeEnv.Schemas, "") + "]"; len(activeEnv.Schemas) > 0 {
if err := maySetFlag(cmd, migrateFlagSchema, s); err != nil {
return err
}
}
return nil
}
type (
// dryRunDriver wraps a migrate.Driver without executing any SQL statements.
dryRunDriver struct{ migrate.Driver }
// dryRunRevisions wraps a migrate.RevisionReadWriter without executing any SQL statements.
dryRunRevisions struct{ migrate.RevisionReadWriter }
)
// QueryContext overrides the wrapped schema.ExecQuerier to not execute any SQL.
func (dryRunDriver) QueryContext(context.Context, string, ...any) (*sql.Rows, error) {
return nil, nil
}
// ExecContext overrides the wrapped schema.ExecQuerier to not execute any SQL.
func (dryRunDriver) ExecContext(context.Context, string, ...any) (sql.Result, error) {
return nil, nil
}
// Lock implements the schema.Locker interface.
func (dryRunDriver) Lock(context.Context, string, time.Duration) (schema.UnlockFunc, error) {
// We dry-run, we don't execute anything. Locking is not required.
return func() error { return nil }, nil
}
// CheckClean implements the migrate.CleanChecker interface.
func (dryRunDriver) CheckClean(context.Context, *migrate.TableIdent) error {
return nil
}
// Snapshot implements the migrate.Snapshoter interface.
func (dryRunDriver) Snapshot(context.Context) (migrate.RestoreFunc, error) {
// We dry-run, we don't execute anything. Snapshotting not required.
return func(context.Context) error { return nil }, nil
}
// WriteRevision overrides the wrapped migrate.RevisionReadWriter to not saved any changes to revisions.
func (dryRunRevisions) WriteRevision(context.Context, *migrate.Revision) error {
return nil
}
atlas-0.7.2/cmd/atlas/internal/cmdapi/migrate_test.go 0000664 0000000 0000000 00000072270 14314555116 0022577 0 ustar 00root root 0000000 0000000 // Copyright 2021-present The Atlas Authors. All rights reserved.
// This source code is licensed under the Apache 2.0 license found
// in the LICENSE file in the root directory of this source tree.
package cmdapi
import (
"context"
"database/sql"
"errors"
"fmt"
"io"
"net/url"
"os"
"os/exec"
"path/filepath"
"runtime"
"strings"
"testing"
"time"
migrate2 "ariga.io/atlas/cmd/atlas/internal/migrate"
"ariga.io/atlas/sql/migrate"
"ariga.io/atlas/sql/schema"
"ariga.io/atlas/sql/sqlclient"
"ariga.io/atlas/sql/sqlite"
_ "ariga.io/atlas/sql/sqlite"
_ "ariga.io/atlas/sql/sqlite/sqlitecheck"
"github.com/fatih/color"
_ "github.com/mattn/go-sqlite3"
"github.com/stretchr/testify/require"
)
func TestMigrate(t *testing.T) {
_, err := runCmd(Root, "migrate")
require.NoError(t, err)
}
func TestMigrate_Import(t *testing.T) {
for _, tool := range []string{"dbmate", "flyway", "golang-migrate", "goose", "liquibase"} {
p := t.TempDir()
t.Run(tool, func(t *testing.T) {
path := filepath.FromSlash("testdata/import/" + tool)
out, err := runCmd(
Root, "migrate", "import",
"--from", "file://"+path,
"--to", "file://"+p,
"--dir-format", tool,
)
require.NoError(t, err)
require.Zero(t, out)
path += "_gold"
ex, err := os.ReadDir(path)
require.NoError(t, err)
ac, err := os.ReadDir(p)
require.NoError(t, err)
require.Equal(t, len(ex)+1, len(ac)) // sum file
for i := range ex {
e, err := os.ReadFile(filepath.Join(path, ex[i].Name()))
require.NoError(t, err)
a, err := os.ReadFile(filepath.Join(p, ex[i].Name()))
require.NoError(t, err)
require.Equal(t, string(e), string(a))
}
})
}
}
func TestMigrate_Apply(t *testing.T) {
var (
p = t.TempDir()
ctx = context.Background()
)
// Disable text coloring in testing
// to assert on string matching.
color.NoColor = true
// Fails on empty directory.
s, err := runCmd(
Root, "migrate", "apply",
"--dir", "file://"+p,
"-u", openSQLite(t, ""),
)
require.NoError(t, err)
require.Equal(t, "No migration files to execute\n", s)
// Fails on directory without sum file.
require.NoError(t, os.Rename(
filepath.FromSlash("testdata/sqlite/atlas.sum"),
filepath.FromSlash("testdata/sqlite/atlas.sum.bak"),
))
t.Cleanup(func() {
os.Rename(filepath.FromSlash("testdata/sqlite/atlas.sum.bak"), filepath.FromSlash("testdata/sqlite/atlas.sum"))
})
_, err = runCmd(
Root, "migrate", "apply",
"--dir", "file://testdata/sqlite",
"--url", openSQLite(t, ""),
)
require.ErrorIs(t, err, migrate.ErrChecksumNotFound)
require.NoError(t, os.Rename(
filepath.FromSlash("testdata/sqlite/atlas.sum.bak"),
filepath.FromSlash("testdata/sqlite/atlas.sum"),
))
// A lock will prevent execution.
sqlclient.Register(
"sqlitelockapply",
sqlclient.OpenerFunc(func(ctx context.Context, u *url.URL) (*sqlclient.Client, error) {
client, err := sqlclient.Open(ctx, strings.Replace(u.String(), u.Scheme, "sqlite", 1))
if err != nil {
return nil, err
}
client.Driver = &sqliteLockerDriver{client.Driver}
return client, nil
}),
sqlclient.RegisterDriverOpener(func(db schema.ExecQuerier) (migrate.Driver, error) {
drv, err := sqlite.Open(db)
if err != nil {
return nil, err
}
return &sqliteLockerDriver{drv}, nil
}),
)
f, err := os.Create(filepath.Join(p, "test.db"))
require.NoError(t, err)
require.NoError(t, f.Close())
s, err = runCmd(
Root, "migrate", "apply",
"--dir", "file://testdata/sqlite",
"--url", fmt.Sprintf("sqlitelockapply://file:%s?cache=shared&_fk=1", filepath.Join(p, "test.db")),
)
require.ErrorIs(t, err, errLock)
require.True(t, strings.HasPrefix(s, "Error: acquiring database lock: "+errLock.Error()))
// Apply zero throws error.
for _, n := range []string{"-1", "0"} {
_, err = runCmd(
Root, "migrate", "apply",
"--dir", "file://testdata/sqlite",
"--url", fmt.Sprintf("sqlite://file:%s?cache=shared&_fk=1", filepath.Join(p, "test.db")),
"--", n,
)
require.EqualError(t, err, fmt.Sprintf("cannot apply '%s' migration files", n))
}
// Will work and print stuff to the console.
s, err = runCmd(
Root, "migrate", "apply",
"--dir", "file://testdata/sqlite",
"--url", fmt.Sprintf("sqlite://file:%s?cache=shared&_fk=1", filepath.Join(p, "test.db")),
"1",
)
require.NoError(t, err)
require.Contains(t, s, "20220318104614") // log to version
require.Contains(t, s, "CREATE TABLE tbl (`col` int NOT NULL);") // logs statement
require.NotContains(t, s, "ALTER TABLE `tbl` ADD `col_2` bigint;") // does not execute second file
require.Contains(t, s, "1 migrations") // logs amount of migrations
require.Contains(t, s, "1 sql statements")
// Transactions will be wrapped per file. If the second file has an error, first still is applied.
s, err = runCmd(
Root, "migrate", "apply",
"--dir", "file://testdata/sqlite2",
"--url", fmt.Sprintf("sqlite://file:%s?cache=shared&_fk=1", filepath.Join(p, "test2.db")),
)
require.Error(t, err)
require.Contains(t, s, "20220318104614") // log to version
require.Contains(t, s, "CREATE TABLE tbl (`col` int NOT NULL);") // logs statement
require.Contains(t, s, "ALTER TABLE `tbl` ADD `col_2` bigint;") // does execute first stmt first second file
require.Contains(t, s, "ALTER TABLE `tbl` ADD `col_3` bigint;") // does execute second stmt first second file
require.NotContains(t, s, "ALTER TABLE `tbl` ADD `col_4` bigint;") // but not third
require.Contains(t, s, "1 migrations ok (1 with errors)") // logs amount of migrations
require.Contains(t, s, "2 sql statements ok (1 with errors)") // logs amount of statement
require.Contains(t, s, "Error: Execution had errors:") // logs error summary
require.Contains(t, s, "near \"asdasd\": syntax error") // logs error summary
c, err := sqlclient.Open(ctx, fmt.Sprintf("sqlite://file:%s?cache=shared&_fk=1", filepath.Join(p, "test2.db")))
require.NoError(t, err)
t.Cleanup(func() {
require.NoError(t, c.Close())
})
sch, err := c.InspectSchema(ctx, "", nil)
tbl, ok := sch.Table("tbl")
require.True(t, ok)
_, ok = tbl.Column("col_2")
require.False(t, ok)
_, ok = tbl.Column("col_3")
require.False(t, ok)
rrw, err := migrate2.NewEntRevisions(ctx, c)
require.NoError(t, err)
revs, err := rrw.ReadRevisions(ctx)
require.NoError(t, err)
require.Len(t, revs, 1)
// Running again will pick up the failed statement and try it again.
s, err = runCmd(
Root, "migrate", "apply",
"--dir", "file://testdata/sqlite2",
"--url", fmt.Sprintf("sqlite://file:%s?cache=shared&_fk=1", filepath.Join(p, "test2.db")),
)
require.Error(t, err)
require.Contains(t, s, "20220318104614") // currently applied version
require.Contains(t, s, "20220318104615") // retry second (partially applied)
require.NotContains(t, s, "CREATE TABLE tbl (`col` int NOT NULL);") // will not attempt stmts from first file
require.Contains(t, s, "ALTER TABLE `tbl` ADD `col_2` bigint;") // picks up first statement
require.Contains(t, s, "ALTER TABLE `tbl` ADD `col_3` bigint;") // does execute second stmt first second file
require.NotContains(t, s, "ALTER TABLE `tbl` ADD `col_4` bigint;") // but not third
require.Contains(t, s, "0 migrations ok (1 with errors)") // logs amount of migrations
require.Contains(t, s, "1 sql statements ok (1 with errors)") // logs amount of statement
require.Contains(t, s, "Error: Execution had errors:") // logs error summary
require.Contains(t, s, "near \"asdasd\": syntax error") // logs error summary
// Editing an applied line will raise error.
s, err = runCmd(
Root, "migrate", "apply",
"--dir", "file://testdata/sqlite2",
"--url", fmt.Sprintf("sqlite://file:%s?cache=shared&_fk=1", filepath.Join(p, "test2.db")),
"--tx-mode", "none",
)
t.Cleanup(func() {
_ = os.RemoveAll("testdata/sqlite3")
})
require.NoError(t, exec.Command("cp", "-r", "testdata/sqlite2", "testdata/sqlite3").Run())
sed(t, "s/col_2/col_5/g", "testdata/sqlite3/20220318104615_second.sql")
_, err = runCmd(Root, "migrate", "hash", "--dir", "file://testdata/sqlite3")
require.NoError(t, err)
s, err = runCmd(
Root, "migrate", "apply",
"--dir", "file://testdata/sqlite3",
"--url", fmt.Sprintf("sqlite://file:%s?cache=shared&_fk=1", filepath.Join(p, "test2.db")),
)
require.ErrorAs(t, err, &migrate.HistoryChangedError{})
// Fixing the migration file will finish without errors.
sed(t, "s/col_5/col_2/g", "testdata/sqlite3/20220318104615_second.sql")
sed(t, "s/asdasd //g", "testdata/sqlite3/20220318104615_second.sql")
_, err = runCmd(Root, "migrate", "hash", "--dir", "file://testdata/sqlite3")
require.NoError(t, err)
s, err = runCmd(
Root, "migrate", "apply",
"--dir", "file://testdata/sqlite3",
"--url", fmt.Sprintf("sqlite://file:%s?cache=shared&_fk=1", filepath.Join(p, "test2.db")),
)
require.NoError(t, err)
require.Contains(t, s, "20220318104615") // retry second (partially applied)
require.Contains(t, s, "ALTER TABLE `tbl` ADD `col_3` bigint;") // does execute second stmt first second file
require.Contains(t, s, "ALTER TABLE `tbl` ADD `col_4` bigint;") // does execute second stmt first second file
require.Contains(t, s, "1 migrations") // logs amount of migrations
require.Contains(t, s, "2") // logs amount of statement
require.NotContains(t, s, "Error: Execution had errors:") // logs error summary
require.NotContains(t, s, "near \"asdasd\": syntax error") // logs error summary
// Running again will report database being in clean state.
s, err = runCmd(
Root, "migrate", "apply",
"--dir", "file://testdata/sqlite3",
"--url", fmt.Sprintf("sqlite://file:%s?cache=shared&_fk=1", filepath.Join(p, "test2.db")),
)
require.NoError(t, err)
require.Equal(t, "No migration files to execute\n", s)
// Dry run will print the statements in second migration file without executing them.
// No changes to the revisions will be done.
s, err = runCmd(
Root, "migrate", "apply",
"--dir", "file://testdata/sqlite",
"--url", fmt.Sprintf("sqlite://file:%s?cache=shared&_fk=1", filepath.Join(p, "test.db")),
"--dry-run",
"1",
)
require.NoError(t, err)
require.Contains(t, s, "20220318104615") // log to version
require.Contains(t, s, "ALTER TABLE `tbl` ADD `col_2` bigint;") // logs statement
c1, err := sqlclient.Open(ctx, fmt.Sprintf("sqlite://file:%s?cache=shared&_fk=1", filepath.Join(p, "test.db")))
require.NoError(t, err)
t.Cleanup(func() {
require.NoError(t, c1.Close())
})
sch, err = c1.InspectSchema(ctx, "", nil)
tbl, ok = sch.Table("tbl")
require.True(t, ok)
_, ok = tbl.Column("col_2")
require.False(t, ok)
rrw, err = migrate2.NewEntRevisions(ctx, c1)
require.NoError(t, err)
revs, err = rrw.ReadRevisions(ctx)
require.NoError(t, err)
require.Len(t, revs, 1)
MigrateFlags.Apply.DryRun = false // global flag, undo for rest of tests
// Prerequisites for testing missing migration behavior.
c1, err = sqlclient.Open(ctx, fmt.Sprintf("sqlite://file:%s?cache=shared&_fk=1", filepath.Join(p, "test3.db")))
require.NoError(t, err)
t.Cleanup(func() {
require.NoError(t, c1.Close())
})
require.NoError(t, os.Rename(
"testdata/sqlite3/20220318104615_second.sql",
"testdata/sqlite3/20220318104616_second.sql",
))
_, err = runCmd(Root, "migrate", "hash", "--dir", "file://testdata/sqlite3")
require.NoError(t, err)
rrw, err = migrate2.NewEntRevisions(ctx, c1)
require.NoError(t, err)
require.NoError(t, rrw.Migrate(ctx))
// No changes if the last revision has a greater version than the last migration.
require.NoError(t, rrw.WriteRevision(ctx, &migrate.Revision{Version: "zzz"}))
s, err = runCmd(
Root, "migrate", "apply",
"--dir", "file://testdata/sqlite3",
"--url", fmt.Sprintf("sqlite://file:%s?cache=shared&_fk=1", filepath.Join(p, "test3.db")),
)
require.NoError(t, err)
require.Equal(t, "No migration files to execute\n", s)
// If the revision is before the last but after the first migration, only the last one is pending.
_, err = c1.ExecContext(ctx, "DROP table `atlas_schema_revisions`")
require.NoError(t, err)
s, err = runCmd(
Root, "migrate", "apply", "1",
"--dir", "file://testdata/sqlite3",
"--url", fmt.Sprintf("sqlite://file:%s?cache=shared&_fk=1", filepath.Join(p, "test3.db")),
)
require.NoError(t, rrw.WriteRevision(ctx, &migrate.Revision{Version: "20220318104615"}))
require.NoError(t, err)
s, err = runCmd(
Root, "migrate", "apply",
"--dir", "file://testdata/sqlite3",
"--url", fmt.Sprintf("sqlite://file:%s?cache=shared&_fk=1", filepath.Join(p, "test3.db")),
)
require.NoError(t, err)
require.NotContains(t, s, "20220318104614") // log to version
require.Contains(t, s, "20220318104616") // log to version
require.Contains(t, s, "ALTER TABLE `tbl` ADD `col_2` bigint;") // logs statement
// If the revision is before every migration file, every file is pending.
_, err = c1.ExecContext(ctx, "DROP table `atlas_schema_revisions`; DROP table `tbl`;")
require.NoError(t, err)
require.NoError(t, rrw.Migrate(ctx))
require.NoError(t, rrw.WriteRevision(ctx, &migrate.Revision{Version: "1"}))
require.NoError(t, err)
s, err = runCmd(
Root, "migrate", "apply",
"--dir", "file://testdata/sqlite3",
"--url", fmt.Sprintf("sqlite://file:%s?cache=shared&_fk=1", filepath.Join(p, "test3.db")),
)
require.NoError(t, err)
require.Contains(t, s, "20220318104614") // log to version
require.Contains(t, s, "20220318104616") // log to version
require.Contains(t, s, "CREATE TABLE tbl (`col` int NOT NULL);") // logs statement
require.Contains(t, s, "ALTER TABLE `tbl` ADD `col_2` bigint;") // logs statement
// If the revision is partially applied, error out.
require.NoError(t, rrw.WriteRevision(ctx, &migrate.Revision{Version: "z", Description: "z", Total: 1}))
require.NoError(t, err)
_, err = runCmd(
Root, "migrate", "apply",
"--dir", "file://testdata/sqlite3",
"--url", fmt.Sprintf("sqlite://file:%s?cache=shared&_fk=1", filepath.Join(p, "test3.db")),
)
require.EqualError(t, err, migrate.MissingMigrationError{Version: "z", Description: "z"}.Error())
}
func TestMigrate_ApplyTxMode(t *testing.T) {
for _, mode := range []string{"none", "file", "all"} {
t.Run(mode, func(t *testing.T) {
p := t.TempDir()
// Apply the first 2 migrations.
s, err := runCmd(
Root, "migrate", "apply",
"--dir", "file://testdata/sqlitetx",
"--url", fmt.Sprintf("sqlite://file:%s?cache=shared&_fk=1", filepath.Join(p, "test.db")),
"--tx-mode", mode,
"2",
)
require.NoError(t, err)
require.NotEmpty(t, s)
db, err := sql.Open("sqlite3", fmt.Sprintf("file:%s?cache=shared&_fk=1", filepath.Join(p, "test.db")))
require.NoError(t, err)
var n int
require.NoError(t, db.QueryRow("SELECT COUNT(*) FROM `friendships`").Scan(&n))
require.Equal(t, 2, n)
// Apply the rest.
s, err = runCmd(
Root, "migrate", "apply",
"--dir", "file://testdata/sqlitetx",
"--url", fmt.Sprintf("sqlite://file:%s?cache=shared&_fk=1", filepath.Join(p, "test.db")),
"--tx-mode", mode,
)
require.NoError(t, err)
require.NoError(t, db.QueryRow("SELECT COUNT(*) FROM `friendships`").Scan(&n))
require.Equal(t, 2, n)
// For transactions check that the foreign keys are checked before the transaction is committed.
if mode != "none" {
// Apply the first 2 migrations for the faulty one.
s, err = runCmd(
Root, "migrate", "apply",
"--dir", "file://testdata/sqlitetx_2",
"--url", fmt.Sprintf("sqlite://file:%s?cache=shared&_fk=1", filepath.Join(p, "test_2.db")),
"--tx-mode", mode,
"2",
)
require.NoError(t, err)
require.NotEmpty(t, s)
db, err = sql.Open("sqlite3", fmt.Sprintf("file:%s?cache=shared&_fk=1", filepath.Join(p, "test_2.db")))
require.NoError(t, err)
require.NoError(t, db.QueryRow("SELECT COUNT(*) FROM `friendships`").Scan(&n))
require.Equal(t, 2, n)
// Add an existing constraint.
c, err := sqlclient.Open(context.Background(), fmt.Sprintf("sqlite://file:%s?cache=shared&_fk=1", filepath.Join(p, "test_2.db")))
require.NoError(t, err)
_, err = c.ExecContext(context.Background(), "PRAGMA foreign_keys = off; INSERT INTO `friendships` (`user_id`, `friend_id`) VALUES (3,3);PRAGMA foreign_keys = on;")
require.NoError(t, err)
require.NoError(t, db.QueryRow("SELECT COUNT(*) FROM `friendships`").Scan(&n))
require.Equal(t, 3, n)
// Apply the rest, expect it to fail due to constraint error, but only the new one is reported.
s, err = runCmd(
Root, "migrate", "apply",
"--dir", "file://testdata/sqlitetx_2",
"--url", fmt.Sprintf("sqlite://file:%s?cache=shared&_fk=1", filepath.Join(p, "test_2.db")),
"--tx-mode", mode,
)
require.EqualError(t, err, "sql/sqlite: foreign key mismatch: [{tbl:friendships ref:users row:4 index:1}]")
require.NoError(t, db.QueryRow("SELECT COUNT(*) FROM `friendships`").Scan(&n))
require.Equal(t, 3, n) // was rolled back
}
})
}
}
func TestMigrate_ApplyBaseline(t *testing.T) {
p := t.TempDir()
// Run migration with baseline should store this revision in the database.
s, err := runCmd(
Root, "migrate", "apply",
"--dir", "file://testdata/baseline1",
"--baseline", "1",
"--url", fmt.Sprintf("sqlite://file:%s?cache=shared&_fk=1", filepath.Join(p, "test.db")),
)
require.NoError(t, err)
require.Contains(t, s, "No migration files to execute")
// Next run without baseline should run the migration from the baseline.
s, err = runCmd(
Root, "migrate", "apply",
"--dir", "file://testdata/baseline2",
"--url", fmt.Sprintf("sqlite://file:%s?cache=shared&_fk=1", filepath.Join(p, "test.db")),
)
require.NoError(t, err)
require.Contains(t, s, "Migrating to version 20220318104615 from 1 (2 migrations in total)")
}
func TestMigrate_Diff(t *testing.T) {
p := t.TempDir()
to := hclURL(t)
// Will create migration directory if not existing.
_, err := runCmd(
Root, "migrate", "diff",
"name",
"--dir", "file://"+filepath.Join(p, "migrations"),
"--dev-url", openSQLite(t, ""),
"--to", to,
)
require.NoError(t, err)
require.FileExists(t, filepath.Join(p, "migrations", fmt.Sprintf("%s_name.sql", time.Now().UTC().Format("20060102150405"))))
// Expect no clean dev error.
p = t.TempDir()
s, err := runCmd(
Root, "migrate", "diff",
"name",
"--dir", "file://"+p,
"--dev-url", openSQLite(t, "create table t (c int);"),
"--to", to,
)
require.ErrorAs(t, err, &migrate.NotCleanError{})
require.ErrorContains(t, err, "found table \"t\"")
// Works (on empty directory).
s, err = runCmd(
Root, "migrate", "diff",
"name",
"--dir", "file://"+p,
"--dev-url", openSQLite(t, ""),
"--to", to,
)
require.NoError(t, err)
require.Zero(t, s)
require.FileExists(t, filepath.Join(p, fmt.Sprintf("%s_name.sql", time.Now().UTC().Format("20060102150405"))))
require.FileExists(t, filepath.Join(p, "atlas.sum"))
// A lock will prevent diffing.
sqlclient.Register("sqlitelockdiff", sqlclient.OpenerFunc(func(ctx context.Context, u *url.URL) (*sqlclient.Client, error) {
client, err := sqlclient.Open(ctx, strings.Replace(u.String(), u.Scheme, "sqlite", 1))
if err != nil {
return nil, err
}
client.Driver = &sqliteLockerDriver{Driver: client.Driver}
return client, nil
}))
f, err := os.Create(filepath.Join(p, "test.db"))
require.NoError(t, err)
require.NoError(t, f.Close())
s, err = runCmd(
Root, "migrate", "diff",
"name",
"--dir", "file://"+t.TempDir(),
"--dev-url", fmt.Sprintf("sqlitelockdiff://file:%s?cache=shared&_fk=1", filepath.Join(p, "test.db")),
"--to", to,
)
require.True(t, strings.HasPrefix(s, "Error: acquiring database lock: "+errLock.Error()))
require.ErrorIs(t, err, errLock)
}
func TestMigrate_New(t *testing.T) {
var (
p = t.TempDir()
v = time.Now().UTC().Format("20060102150405")
)
s, err := runCmd(Root, "migrate", "new", "--dir", "file://"+p)
require.Zero(t, s)
require.NoError(t, err)
require.FileExists(t, filepath.Join(p, v+".sql"))
require.FileExists(t, filepath.Join(p, "atlas.sum"))
require.Equal(t, 2, countFiles(t, p))
s, err = runCmd(Root, "migrate", "new", "my-migration-file", "--dir", "file://"+p)
require.Zero(t, s)
require.NoError(t, err)
require.FileExists(t, filepath.Join(p, v+"_my-migration-file.sql"))
require.FileExists(t, filepath.Join(p, "atlas.sum"))
require.Equal(t, 3, countFiles(t, p))
p = t.TempDir()
s, err = runCmd(Root, "migrate", "new", "golang-migrate", "--dir", "file://"+p, "--dir-format", formatGolangMigrate)
require.Zero(t, s)
require.NoError(t, err)
require.FileExists(t, filepath.Join(p, v+"_golang-migrate.up.sql"))
require.FileExists(t, filepath.Join(p, v+"_golang-migrate.down.sql"))
require.Equal(t, 3, countFiles(t, p))
p = t.TempDir()
s, err = runCmd(Root, "migrate", "new", "goose", "--dir", "file://"+p, "--dir-format", formatGoose)
require.Zero(t, s)
require.NoError(t, err)
require.FileExists(t, filepath.Join(p, v+"_goose.sql"))
require.Equal(t, 2, countFiles(t, p))
p = t.TempDir()
s, err = runCmd(Root, "migrate", "new", "flyway", "--dir", "file://"+p, "--dir-format", formatFlyway)
require.Zero(t, s)
require.NoError(t, err)
require.FileExists(t, filepath.Join(p, fmt.Sprintf("V%s__%s.sql", v, formatFlyway)))
require.FileExists(t, filepath.Join(p, fmt.Sprintf("U%s__%s.sql", v, formatFlyway)))
require.Equal(t, 3, countFiles(t, p))
p = t.TempDir()
s, err = runCmd(Root, "migrate", "new", "liquibase", "--dir", "file://"+p, "--dir-format", formatLiquibase)
require.Zero(t, s)
require.NoError(t, err)
require.FileExists(t, filepath.Join(p, v+"_liquibase.sql"))
require.Equal(t, 2, countFiles(t, p))
p = t.TempDir()
s, err = runCmd(Root, "migrate", "new", "dbmate", "--dir", "file://"+p, "--dir-format", formatDBMate)
require.Zero(t, s)
require.NoError(t, err)
require.FileExists(t, filepath.Join(p, v+"_dbmate.sql"))
require.Equal(t, 2, countFiles(t, p))
f := filepath.Join("testdata", "mysql", "new.sql")
require.NoError(t, os.WriteFile(f, []byte("contents"), 0600))
t.Cleanup(func() { os.Remove(f) })
s, err = runCmd(Root, "migrate", "new", "--dir", "file://testdata/mysql")
require.NotZero(t, s)
require.Error(t, err)
}
func TestMigrate_Validate(t *testing.T) {
// Without re-playing.
MigrateFlags.DevURL = "" // global flags are set from other tests ...
MigrateFlags.DirFormat = "atlas" // global flags are set from other tests ...
s, err := runCmd(Root, "migrate", "validate", "--dir", "file://testdata/mysql")
require.Zero(t, s)
require.NoError(t, err)
f := filepath.Join("testdata", "mysql", "new.sql")
require.NoError(t, os.WriteFile(f, []byte("contents"), 0600))
t.Cleanup(func() { os.Remove(f) })
s, err = runCmd(Root, "migrate", "validate", "--dir", "file://testdata/mysql")
require.NotZero(t, s)
require.Error(t, err)
require.NoError(t, os.Remove(f))
// Replay migration files if a dev-url is given.
p := t.TempDir()
require.NoError(t, os.WriteFile(filepath.Join(p, "1_initial.sql"), []byte("create table t1 (c1 int)"), 0644))
require.NoError(t, os.WriteFile(filepath.Join(p, "2_second.sql"), []byte("create table t2 (c2 int)"), 0644))
_, err = runCmd(Root, "migrate", "hash", "--dir", "file://"+p)
require.NoError(t, err)
s, err = runCmd(
Root, "migrate", "validate",
"--dir", "file://"+p,
"--dev-url", openSQLite(t, ""),
)
require.Zero(t, s)
require.NoError(t, err)
// Should fail since the files are not compatible with SQLite.
_, err = runCmd(Root, "migrate", "validate", "--dir", "file://testdata/mysql", "--dev-url", openSQLite(t, ""))
require.Error(t, err)
}
func TestMigrate_Hash(t *testing.T) {
s, err := runCmd(Root, "migrate", "hash", "--dir", "file://testdata/mysql")
require.Zero(t, s)
require.NoError(t, err)
// Prints a warning if --force flag is still used.
s, err = runCmd(Root, "migrate", "hash", "--dir", "file://testdata/mysql", "--force")
require.NoError(t, err)
require.Equal(t, "Flag --force has been deprecated, you can safely omit it.\n", s)
p := t.TempDir()
err = copyFile(filepath.Join("testdata", "mysql", "20220318104614_initial.sql"), filepath.Join(p, "20220318104614_initial.sql"))
require.NoError(t, err)
s, err = runCmd(Root, "migrate", "hash", "--dir", "file://"+p)
require.Zero(t, s)
require.NoError(t, err)
require.FileExists(t, filepath.Join(p, "atlas.sum"))
d, err := os.ReadFile(filepath.Join(p, "atlas.sum"))
require.NoError(t, err)
dir, err := migrate.NewLocalDir(p)
require.NoError(t, err)
sum, err := dir.Checksum()
require.NoError(t, err)
b, err := sum.MarshalText()
require.NoError(t, err)
require.Equal(t, d, b)
p = t.TempDir()
require.NoError(t, copyFile(
filepath.Join("testdata", "mysql", "20220318104614_initial.sql"),
filepath.Join(p, "20220318104614_initial.sql"),
))
s, err = runCmd(Root, "migrate", "hash", "--dir", "file://"+os.Getenv("MIGRATION_DIR"))
require.NotZero(t, s)
require.Error(t, err)
}
func TestMigrate_Lint(t *testing.T) {
p := t.TempDir()
s, err := runCmd(
Root, "migrate", "lint",
"--dir", "file://"+p,
"--dev-url", openSQLite(t, ""),
"--latest", "1",
)
require.NoError(t, err)
require.Empty(t, s)
err = os.WriteFile(filepath.Join(p, "1.sql"), []byte("CREATE TABLE t(c int);"), 0600)
require.NoError(t, err)
err = os.WriteFile(filepath.Join(p, "2.sql"), []byte("DROP TABLE t;"), 0600)
require.NoError(t, err)
s, err = runCmd(
Root, "migrate", "lint",
"--dir", "file://"+p,
"--dev-url", openSQLite(t, ""),
"--latest", "1",
)
require.Error(t, err)
require.Equal(t, "2.sql: destructive changes detected:\n\n\tL1: Dropping table \"t\"\n\n", s)
s, err = runCmd(
Root, "migrate", "lint",
"--dir", "file://"+p,
"--dev-url", openSQLite(t, ""),
"--latest", "1",
"--log", "{{ range .Files }}{{ .Name }}{{ end }}",
)
require.Error(t, err)
require.Equal(t, "2.sql", s)
// Change files to golang-migrate format.
require.NoError(t, os.Rename(filepath.Join(p, "1.sql"), filepath.Join(p, "1.up.sql")))
require.NoError(t, os.Rename(filepath.Join(p, "2.sql"), filepath.Join(p, "1.down.sql")))
s, err = runCmd(
Root, "migrate", "lint",
"--dir", "file://"+p,
"--dir-format", "golang-migrate",
"--dev-url", openSQLite(t, ""),
"--latest", "2",
"--log", "{{ range .Files }}{{ .Name }}:{{ len .Reports }}{{ end }}",
)
require.NoError(t, err)
require.Equal(t, "1.up.sql:0", s)
// Invalid files.
MigrateFlags.Lint.Format = ""
err = os.WriteFile(filepath.Join(p, "2.up.sql"), []byte("BORING"), 0600)
require.NoError(t, err)
s, err = runCmd(
Root, "migrate", "lint",
"--dir", "file://"+p,
"--dir-format", "golang-migrate",
"--dev-url", openSQLite(t, ""),
"--latest", "1",
)
require.Error(t, err)
require.Equal(t, "2.up.sql: executing statement: near \"BORING\": syntax error\n", s)
}
const testSchema = `
schema "main" {
}
table "table" {
schema = schema.main
column "col" {
type = int
comment = "column comment"
}
column "age" {
type = int
}
column "price1" {
type = int
}
column "price2" {
type = int
}
column "account_name" {
type = varchar(32)
null = true
}
column "created_at" {
type = datetime
default = sql("current_timestamp")
}
primary_key {
columns = [table.table.column.col]
}
index "index" {
unique = true
columns = [
table.table.column.col,
table.table.column.age,
]
comment = "index comment"
}
foreign_key "accounts" {
columns = [
table.table.column.account_name,
]
ref_columns = [
table.accounts.column.name,
]
on_delete = SET_NULL
on_update = "NO_ACTION"
}
check "positive price" {
expr = "price1 > 0"
}
check {
expr = "price1 <> price2"
enforced = true
}
check {
expr = "price2 <> price1"
enforced = false
}
comment = "table comment"
}
table "accounts" {
schema = schema.main
column "name" {
type = varchar(32)
}
column "unsigned_float" {
type = float(10)
unsigned = true
}
column "unsigned_decimal" {
type = decimal(10, 2)
unsigned = true
}
primary_key {
columns = [table.accounts.column.name]
}
}`
func hclURL(t *testing.T) string {
p := t.TempDir()
require.NoError(t, os.WriteFile(filepath.Join(p, "schema.hcl"), []byte(testSchema), 0600))
return "file://" + filepath.Join(p, "schema.hcl")
}
func copyFile(src, dst string) error {
sf, err := os.Open(src)
if err != nil {
return err
}
defer sf.Close()
df, err := os.Create(dst)
if err != nil {
return err
}
defer df.Close()
_, err = io.Copy(df, sf)
return err
}
type sqliteLockerDriver struct{ migrate.Driver }
var errLock = errors.New("lockErr")
func (d *sqliteLockerDriver) Lock(context.Context, string, time.Duration) (schema.UnlockFunc, error) {
return func() error { return nil }, errLock
}
func (d *sqliteLockerDriver) Snapshot(ctx context.Context) (migrate.RestoreFunc, error) {
return d.Driver.(migrate.Snapshoter).Snapshot(ctx)
}
func (d *sqliteLockerDriver) CheckClean(ctx context.Context, revT *migrate.TableIdent) error {
return d.Driver.(migrate.CleanChecker).CheckClean(ctx, revT)
}
func countFiles(t *testing.T, p string) int {
files, err := os.ReadDir(p)
require.NoError(t, err)
return len(files)
}
func sed(t *testing.T, r, p string) {
args := []string{"-i"}
if runtime.GOOS == "darwin" {
args = append(args, ".bk")
}
buf, err := exec.Command("sed", append(args, r, p)...).CombinedOutput()
require.NoError(t, err, string(buf))
}
atlas-0.7.2/cmd/atlas/internal/cmdapi/project.go 0000664 0000000 0000000 00000012245 14314555116 0021552 0 ustar 00root root 0000000 0000000 // Copyright 2021-present The Atlas Authors. All rights reserved.
// This source code is licensed under the Apache 2.0 license found
// in the LICENSE file in the root directory of this source tree.
package cmdapi
import (
"errors"
"fmt"
"os"
"ariga.io/atlas/schemahcl"
)
const projectFileName = "atlas.hcl"
type loadConfig struct {
inputVals map[string]string
}
// LoadOption configures the LoadEnv function.
type LoadOption func(*loadConfig)
// WithInput is a LoadOption that sets the input values for the LoadEnv function.
func WithInput(vals map[string]string) LoadOption {
return func(config *loadConfig) {
config.inputVals = vals
}
}
type (
// Project represents an atlas.hcl project file.
Project struct {
Envs []*Env `spec:"env"` // List of environments
Lint *Lint `spec:"lint"` // Optional global lint config
}
// Env represents an Atlas environment.
Env struct {
// Name for this environment.
Name string `spec:"name,name"`
// URL of the database.
URL string `spec:"url"`
// URL of the dev-database for this environment.
// See: https://atlasgo.io/dev-database
DevURL string `spec:"dev"`
// List of schemas in this database that are managed by Atlas.
Schemas []string `spec:"schemas"`
// Exclude defines a list of glob patterns used to filter
// resources on inspection.
Exclude []string `spec:"exclude"`
// Migration containing the migration configuration of the env.
Migration *Migration `spec:"migration"`
// Lint of the environment.
Lint *Lint `spec:"lint"`
schemahcl.DefaultExtension
}
// Migration represents the migration directory for the Env.
Migration struct {
Dir string `spec:"dir"`
Format string `spec:"format"`
RevisionsSchema string `spec:"revisions_schema"`
}
// Lint represents the configuration of migration linting.
Lint struct {
// Log configures the --log option.
Log string `spec:"log"`
// Latest configures the --latest option.
Latest int `spec:"latest"`
Git struct {
// Dir configures the --git-dir option.
Dir string `spec:"dir"`
// Base configures the --git-base option.
Base string `spec:"base"`
} `spec:"git"`
schemahcl.DefaultExtension
}
)
// Extend allows extending environment blocks with
// a global one. For example:
//
// lint {
// log = < schema.hcl
This file can then be edited and used with the` + " `atlas schema apply` " + `command to plan
and execute schema migrations against the given database. In cases where users wish to inspect
all multiple schemas in a given database (for instance a MySQL server may contain multiple named
databases), omit the relevant part from the url, e.g. "mysql://user:pass@localhost:3306/".
To select specific schemas from the databases, users may use the "--schema" (or "-s" shorthand)
flag.
`,
PreRunE: schemaFlagsFromEnv,
RunE: CmdInspectRun,
Example: ` atlas schema inspect -u "mysql://user:pass@localhost:3306/dbname"
atlas schema inspect -u "mariadb://user:pass@localhost:3306/" --schema=schemaA,schemaB -s schemaC
atlas schema inspect --url "postgres://user:pass@host:port/dbname?sslmode=disable"
atlas schema inspect -u "sqlite://file:ex1.db?_fk=1"`,
}
// SchemaFmt represents the 'atlas schema fmt' subcommand.
SchemaFmt = &cobra.Command{
Use: "fmt [path ...]",
Short: "Formats Atlas HCL files",
Long: `'atlas schema fmt' formats all ".hcl" files under the given path using
canonical HCL layout style as defined by the github.com/hashicorp/hcl/v2/hclwrite package.
Unless stated otherwise, the fmt command will use the current directory.
After running, the command will print the names of the files it has formatted. If all
files in the directory are formatted, no input will be printed out.
`,
Run: CmdFmtRun,
}
)
const (
answerApply = "Apply"
answerAbort = "Abort"
)
func init() {
// Common flags.
receivesEnv(schemaCmd)
// Schema apply flags.
schemaCmd.AddCommand(SchemaApply)
SchemaApply.Flags().SortFlags = false
SchemaApply.Flags().StringSliceVarP(&ApplyFlags.Paths, fileFlag, "f", nil, "[paths...] file or directory containing the HCL files")
SchemaApply.Flags().StringVarP(&SchemaFlags.URL, urlFlag, "u", "", "URL to the database using the format:\n[driver://username:password@address/dbname?param=value]")
SchemaApply.Flags().StringSliceVarP(&SchemaFlags.Exclude, excludeFlag, "", nil, "List of glob patterns used to filter resources from applying.")
SchemaApply.Flags().StringSliceVarP(&SchemaFlags.Schemas, schemaFlag, "s", nil, "Set schema names.")
SchemaApply.Flags().StringVarP(&ApplyFlags.DevURL, devURLFlag, "", "", "URL for the dev database. Used to validate schemas and calculate diffs\nbefore running migration.")
SchemaApply.Flags().BoolVarP(&ApplyFlags.DryRun, "dry-run", "", false, "Dry-run. Print SQL plan without prompting for execution.")
SchemaApply.Flags().BoolVarP(&ApplyFlags.AutoApprove, autoApproveFlag, "", false, "Auto approve. Apply the schema changes without prompting for approval.")
SchemaApply.Flags().StringVarP(&SchemaFlags.DSN, dsnFlag, "d", "", "")
cobra.CheckErr(SchemaApply.Flags().MarkHidden(dsnFlag))
cobra.CheckErr(SchemaApply.MarkFlagRequired(urlFlag))
cobra.CheckErr(SchemaApply.MarkFlagRequired(fileFlag))
// Schema clean flags.
SchemaClean.Flags().StringVarP(&CleanFlags.URL, urlFlag, "u", "", "URL to the database using the format:\n[driver://username:password@address/dbname?param=value]")
SchemaClean.Flags().BoolVarP(&CleanFlags.AutoApprove, autoApproveFlag, "", false, "Auto approve. Apply the schema changes without prompting for approval.")
cobra.CheckErr(SchemaClean.MarkFlagRequired(urlFlag))
// Schema inspect flags.
schemaCmd.AddCommand(SchemaInspect)
SchemaInspect.Flags().StringVarP(&SchemaFlags.URL, urlFlag, "u", "", "[driver://username:password@protocol(address)/dbname?param=value] select a database using the URL format")
SchemaInspect.Flags().StringSliceVarP(&SchemaFlags.Schemas, schemaFlag, "s", nil, "Set schema name")
SchemaInspect.Flags().StringSliceVarP(&SchemaFlags.Exclude, excludeFlag, "", nil, "List of glob patterns used to filter resources from inspection")
SchemaInspect.Flags().StringVarP(&SchemaFlags.DSN, dsnFlag, "d", "", "")
cobra.CheckErr(SchemaInspect.Flags().MarkHidden(dsnFlag))
cobra.CheckErr(SchemaInspect.MarkFlagRequired(urlFlag))
// Schema fmt.
schemaCmd.AddCommand(SchemaFmt)
schemaCmd.AddCommand(SchemaClean)
}
// selectEnv returns the Env from the current project file based on the selected
// argument. If selected is "", or no project file exists in the current directory
// a zero-value Env is returned.
func selectEnv(selected string) (*Env, error) {
env := &Env{
Lint: &Lint{},
Migration: &Migration{},
}
if selected == "" {
return env, nil
}
if _, err := os.Stat(projectFileName); os.IsNotExist(err) {
return nil, fmt.Errorf("project file %q was not found", projectFileName)
}
return LoadEnv(projectFileName, selected, WithInput(GlobalFlags.Vars))
}
func schemaFlagsFromEnv(cmd *cobra.Command, _ []string) error {
activeEnv, err := selectEnv(GlobalFlags.SelectedEnv)
if err != nil {
return err
}
if err := inputValsFromEnv(cmd); err != nil {
return err
}
if err := dsn2url(cmd); err != nil {
return err
}
if err := maySetFlag(cmd, urlFlag, activeEnv.URL); err != nil {
return err
}
if err := maySetFlag(cmd, devURLFlag, activeEnv.DevURL); err != nil {
return err
}
srcs, err := activeEnv.Sources()
if err != nil {
return err
}
if err := maySetFlag(cmd, fileFlag, strings.Join(srcs, "")); err != nil {
return err
}
if s := strings.Join(activeEnv.Schemas, ","); s != "" {
if err := maySetFlag(cmd, schemaFlag, s); err != nil {
return err
}
}
if s := strings.Join(activeEnv.Exclude, ","); s != "" {
if err := maySetFlag(cmd, excludeFlag, s); err != nil {
return err
}
}
return nil
}
// maySetFlag sets the flag with the provided name to envVal if such a flag exists
// on the cmd, it was not set by the user via the command line and if envVal is not
// an empty string.
func maySetFlag(cmd *cobra.Command, name, envVal string) error {
fl := cmd.Flag(name)
if fl == nil {
return nil
}
if fl.Changed {
return nil
}
if envVal == "" {
return nil
}
return cmd.Flags().Set(name, envVal)
}
func dsn2url(cmd *cobra.Command) error {
dsnF, urlF := cmd.Flag(dsnFlag), cmd.Flag(urlFlag)
switch {
case dsnF == nil:
case dsnF.Changed && urlF.Changed:
return errors.New(`both flags "url" and "dsn" were set`)
case dsnF.Changed && !urlF.Changed:
return cmd.Flags().Set(urlFlag, dsnF.Value.String())
}
return nil
}
// CmdInspectRun is the command used when running CLI.
func CmdInspectRun(cmd *cobra.Command, _ []string) error {
// Create the client.
client, err := sqlclient.Open(cmd.Context(), SchemaFlags.URL)
if err != nil {
return err
}
defer client.Close()
schemas := SchemaFlags.Schemas
if client.URL.Schema != "" {
schemas = append(schemas, client.URL.Schema)
}
s, err := client.InspectRealm(cmd.Context(), &schema.InspectRealmOption{
Schemas: schemas,
Exclude: SchemaFlags.Exclude,
})
if err != nil {
return err
}
ddl, err := client.MarshalSpec(s)
if err != nil {
return err
}
cmd.Print(string(ddl))
return nil
}
// CmdApplyRun is the command used when running CLI.
func CmdApplyRun(cmd *cobra.Command, _ []string) error {
c, err := sqlclient.Open(cmd.Context(), SchemaFlags.URL)
if err != nil {
return err
}
defer c.Close()
return applyRun(cmd, c, ApplyFlags.DevURL, ApplyFlags.Paths, ApplyFlags.DryRun, ApplyFlags.AutoApprove, GlobalFlags.Vars)
}
// CmdCleanRun is the command executed when running the CLI with 'schema clean' args.
func CmdCleanRun(cmd *cobra.Command, _ []string) error {
// Open a client to the database.
c, err := sqlclient.Open(cmd.Context(), CleanFlags.URL)
if err != nil {
return err
}
defer c.Close()
var drop []schema.Change
// If the connection is bound to a schema, only drop the resources inside the schema.
switch c.URL.Schema {
case "":
r, err := c.InspectRealm(cmd.Context(), nil)
if err != nil {
return err
}
drop, err = c.RealmDiff(r, nil)
if err != nil {
return err
}
default:
s, err := c.InspectSchema(cmd.Context(), c.URL.Schema, nil)
if err != nil {
return err
}
drop, err = c.SchemaDiff(s, schema.New(s.Name))
if err != nil {
return err
}
}
if len(drop) == 0 {
cmd.Println("Nothing to drop")
return nil
}
if err := summary(cmd, c, drop); err != nil {
return err
}
if CleanFlags.AutoApprove || promptUser() {
if err := c.ApplyChanges(cmd.Context(), drop); err != nil {
return err
}
}
return nil
}
func summary(cmd *cobra.Command, drv migrate.Driver, changes []schema.Change) error {
p, err := drv.PlanChanges(cmd.Context(), "", changes)
if err != nil {
return err
}
cmd.Println("-- Planned Changes:")
for _, c := range p.Changes {
if c.Comment != "" {
cmd.Println("--", strings.ToUpper(c.Comment[:1])+c.Comment[1:])
}
cmd.Println(c.Cmd)
}
return nil
}
// CmdFmtRun formats all HCL files in a given directory using canonical HCL formatting
// rules.
func CmdFmtRun(cmd *cobra.Command, args []string) {
if len(args) == 0 {
args = append(args, "./")
}
for _, path := range args {
handlePath(cmd, path)
}
}
func applyRun(cmd *cobra.Command, client *sqlclient.Client, devURL string, paths []string, dryRun, autoApprove bool, input map[string]string) error {
schemas, ctx := SchemaFlags.Schemas, cmd.Context()
if client.URL.Schema != "" {
schemas = append(schemas, client.URL.Schema)
}
realm, err := client.InspectRealm(ctx, &schema.InspectRealmOption{
Schemas: schemas,
Exclude: SchemaFlags.Exclude,
})
if err != nil {
return err
}
desired := &schema.Realm{}
parsed, err := parseHCLPaths(paths...)
if err != nil {
return err
}
if err := client.Eval(parsed, desired, input); err != nil {
return err
}
if len(schemas) > 0 {
// Validate all schemas in file were selected by user.
sm := make(map[string]bool, len(schemas))
for _, s := range schemas {
sm[s] = true
}
for _, s := range desired.Schemas {
if !sm[s.Name] {
return fmt.Errorf("schema %q was not selected %q, all schemas defined in file must be selected", s.Name, schemas)
}
}
}
if _, ok := client.Driver.(schema.Normalizer); ok && devURL != "" {
dev, err := sqlclient.Open(ctx, ApplyFlags.DevURL)
if err != nil {
return err
}
defer dev.Close()
desired, err = dev.Driver.(schema.Normalizer).NormalizeRealm(ctx, desired)
if err != nil {
return err
}
}
changes, err := client.RealmDiff(realm, desired)
if err != nil {
return err
}
if len(changes) == 0 {
cmd.Println("Schema is synced, no changes to be made")
return nil
}
if err := summary(cmd, client, changes); err != nil {
return err
}
if !dryRun && (autoApprove || promptUser()) {
if err := client.ApplyChanges(ctx, changes); err != nil {
return err
}
}
return nil
}
func promptUser() bool {
prompt := promptui.Select{
Label: "Are you sure?",
Items: []string{answerApply, answerAbort},
}
_, result, err := prompt.Run()
cobra.CheckErr(err)
return result == answerApply
}
func handlePath(cmd *cobra.Command, path string) {
tasks, err := tasks(path)
cobra.CheckErr(err)
for _, task := range tasks {
changed, err := fmtFile(task)
cobra.CheckErr(err)
if changed {
cmd.Println(task.path)
}
}
}
func tasks(path string) ([]fmttask, error) {
var tasks []fmttask
stat, err := os.Stat(path)
if err != nil {
return nil, err
}
if !stat.IsDir() {
if strings.HasSuffix(path, ".hcl") {
tasks = append(tasks, fmttask{
path: path,
info: stat,
})
}
return tasks, nil
}
all, err := os.ReadDir(path)
if err != nil {
return nil, err
}
for _, f := range all {
if f.IsDir() {
continue
}
if strings.HasSuffix(f.Name(), ".hcl") {
i, err := f.Info()
if err != nil {
return nil, err
}
tasks = append(tasks, fmttask{
path: filepath.Join(path, f.Name()),
info: i,
})
}
}
return tasks, nil
}
type fmttask struct {
path string
info fs.FileInfo
}
// fmtFile tries to format a file and reports if formatting occurred.
func fmtFile(task fmttask) (bool, error) {
orig, err := os.ReadFile(task.path)
if err != nil {
return false, err
}
formatted := hclwrite.Format(orig)
if !bytes.Equal(formatted, orig) {
return true, os.WriteFile(task.path, formatted, task.info.Mode())
}
return false, nil
}
atlas-0.7.2/cmd/atlas/internal/cmdapi/schema_test.go 0000664 0000000 0000000 00000010020 14314555116 0022370 0 ustar 00root root 0000000 0000000 // Copyright 2021-present The Atlas Authors. All rights reserved.
// This source code is licensed under the Apache 2.0 license found
// in the LICENSE file in the root directory of this source tree.
package cmdapi
import (
"bytes"
"context"
"fmt"
"io/ioutil"
"os"
"path"
"path/filepath"
"testing"
"ariga.io/atlas/sql/migrate"
"ariga.io/atlas/sql/sqlclient"
"github.com/stretchr/testify/require"
)
const (
unformatted = `block "x" {
x = 1
y = 2
}
`
formatted = `block "x" {
x = 1
y = 2
}
`
)
func TestFmt(t *testing.T) {
for _, tt := range []struct {
name string
inputDir map[string]string
expectedDir map[string]string
expectedFile string
expectedOut string
args []string
expectedPrint bool
}{
{
name: "specific file",
inputDir: map[string]string{
"test.hcl": unformatted,
},
expectedDir: map[string]string{
"test.hcl": formatted,
},
args: []string{"test.hcl"},
expectedOut: "test.hcl\n",
},
{
name: "current dir",
inputDir: map[string]string{
"test.hcl": unformatted,
},
expectedDir: map[string]string{
"test.hcl": formatted,
},
expectedOut: "test.hcl\n",
},
{
name: "multi path implicit",
inputDir: map[string]string{
"test.hcl": unformatted,
"test2.hcl": unformatted,
},
expectedDir: map[string]string{
"test.hcl": formatted,
"test2.hcl": formatted,
},
expectedOut: "test.hcl\ntest2.hcl\n",
},
{
name: "multi path explicit",
inputDir: map[string]string{
"test.hcl": unformatted,
"test2.hcl": unformatted,
},
expectedDir: map[string]string{
"test.hcl": formatted,
"test2.hcl": formatted,
},
args: []string{"test.hcl", "test2.hcl"},
expectedOut: "test.hcl\ntest2.hcl\n",
},
{
name: "formatted",
inputDir: map[string]string{
"test.hcl": formatted,
},
expectedDir: map[string]string{
"test.hcl": formatted,
},
},
} {
t.Run(tt.name, func(t *testing.T) {
dir := setupFmtTest(t, tt.inputDir)
out := runFmt(t, tt.args)
assertDir(t, dir, tt.expectedDir)
require.EqualValues(t, tt.expectedOut, out)
})
}
}
func TestSchema_Clean(t *testing.T) {
var (
u = fmt.Sprintf("sqlite://file:%s?cache=shared&_fk=1", filepath.Join(t.TempDir(), "test.db"))
c, err = sqlclient.Open(context.Background(), u)
)
require.NoError(t, err)
// Apply migrations onto database.
_, err = runCmd(Root, "migrate", "apply", "--dir", "file://testdata/sqlite", "--url", u)
require.NoError(t, err)
// Run clean and expect to be clean.
_, err = runCmd(Root, "migrate", "apply", "--dir", "file://testdata/sqlite", "--url", u)
require.NoError(t, err)
s, err := runCmd(Root, "schema", "clean", "--url", u, "--auto-approve")
require.NoError(t, err)
require.NotZero(t, s)
require.NoError(t, c.Driver.(migrate.CleanChecker).CheckClean(context.Background(), nil))
}
func runFmt(t *testing.T, args []string) string {
var out bytes.Buffer
SchemaFmt.ResetCommands() // Detach from sub-commands and parents, needed to skip input validation done by them.
SchemaFmt.SetOut(&out)
SchemaFmt.SetArgs(args)
err := SchemaFmt.Execute()
require.NoError(t, err)
return out.String()
}
func assertDir(t *testing.T, dir string, expected map[string]string) {
act := make(map[string]string)
files, err := ioutil.ReadDir(dir)
require.NoError(t, err)
for _, f := range files {
if f.IsDir() {
continue
}
contents, err := os.ReadFile(filepath.Join(dir, f.Name()))
require.NoError(t, err)
act[f.Name()] = string(contents)
}
require.EqualValues(t, expected, act)
}
func setupFmtTest(t *testing.T, inputDir map[string]string) string {
wd, err := os.Getwd()
require.NoError(t, err)
dir, err := os.MkdirTemp(os.TempDir(), "fmt-test-")
require.NoError(t, err)
err = os.Chdir(dir)
require.NoError(t, err)
t.Cleanup(func() {
os.RemoveAll(dir)
os.Chdir(wd) //nolint:errcheck
})
for name, contents := range inputDir {
file := path.Join(dir, name)
err = os.WriteFile(file, []byte(contents), 0600)
}
require.NoError(t, err)
return dir
}
atlas-0.7.2/cmd/atlas/internal/cmdapi/testdata/ 0000775 0000000 0000000 00000000000 14314555116 0021362 5 ustar 00root root 0000000 0000000 atlas-0.7.2/cmd/atlas/internal/cmdapi/testdata/baseline1/ 0000775 0000000 0000000 00000000000 14314555116 0023225 5 ustar 00root root 0000000 0000000 atlas-0.7.2/cmd/atlas/internal/cmdapi/testdata/baseline1/1_baseline.sql 0000664 0000000 0000000 00000000105 14314555116 0025744 0 ustar 00root root 0000000 0000000 -- create "baseline" table
CREATE TABLE baseline (`c` int NOT NULL);
atlas-0.7.2/cmd/atlas/internal/cmdapi/testdata/baseline1/atlas.sum 0000664 0000000 0000000 00000000157 14314555116 0025062 0 ustar 00root root 0000000 0000000 h1:GqOjMVGk2H0qYhhtJ1SPCyyHEBbWP/LD2ueWQTY4e6A=
1_baseline.sql h1:rZgkRmNcN2UEKgxru1nHCpBRVn/fjFavyQ4xxPxhrD4=
atlas-0.7.2/cmd/atlas/internal/cmdapi/testdata/baseline2/ 0000775 0000000 0000000 00000000000 14314555116 0023226 5 ustar 00root root 0000000 0000000 atlas-0.7.2/cmd/atlas/internal/cmdapi/testdata/baseline2/1_baseline.sql 0000664 0000000 0000000 00000000105 14314555116 0025745 0 ustar 00root root 0000000 0000000 -- create "baseline" table
CREATE TABLE baseline (`c` int NOT NULL);
atlas-0.7.2/cmd/atlas/internal/cmdapi/testdata/baseline2/20220318104614_initial.sql 0000664 0000000 0000000 00000000075 14314555116 0027043 0 ustar 00root root 0000000 0000000 -- create "tbl" table
CREATE TABLE tbl (`col` int NOT NULL);
atlas-0.7.2/cmd/atlas/internal/cmdapi/testdata/baseline2/20220318104615_second.sql 0000664 0000000 0000000 00000000046 14314555116 0026664 0 ustar 00root root 0000000 0000000 ALTER TABLE `tbl` ADD `col_2` bigint;
atlas-0.7.2/cmd/atlas/internal/cmdapi/testdata/baseline2/atlas.sum 0000664 0000000 0000000 00000000404 14314555116 0025056 0 ustar 00root root 0000000 0000000 h1:sxNQqhuqhm1fLpr3WN9N/M/niaS81Y7k5RrSaKpmBZE=
1_baseline.sql h1:rZgkRmNcN2UEKgxru1nHCpBRVn/fjFavyQ4xxPxhrD4=
20220318104614_initial.sql h1:/B1/+IxzgrRc4tCm1tpcpMhocHgqkdWF+iffxuguYaQ=
20220318104615_second.sql h1:nUc1cUvm8BzjTZdbavM1IRlNpfhtyY3YyZJ8v23K9j4=
atlas-0.7.2/cmd/atlas/internal/cmdapi/testdata/import/ 0000775 0000000 0000000 00000000000 14314555116 0022674 5 ustar 00root root 0000000 0000000 atlas-0.7.2/cmd/atlas/internal/cmdapi/testdata/import/dbmate/ 0000775 0000000 0000000 00000000000 14314555116 0024130 5 ustar 00root root 0000000 0000000 atlas-0.7.2/cmd/atlas/internal/cmdapi/testdata/import/dbmate/1_initial.sql 0000664 0000000 0000000 00000000523 14314555116 0026522 0 ustar 00root root 0000000 0000000 -- migrate:up
CREATE TABLE post
(
id int NOT NULL,
title text,
body text,
PRIMARY KEY (id)
);
/*
Multiline comment ...
*/
ALTER TABLE post ADD created_at TIMESTAMP NOT NULL;
-- Normal comment
-- With a second line
INSERT INTO post (title) VALUES (
'This is
my multiline
value');
-- migrate:down
DROP TABLE post; atlas-0.7.2/cmd/atlas/internal/cmdapi/testdata/import/dbmate/2_second_migration.sql 0000664 0000000 0000000 00000000062 14314555116 0030414 0 ustar 00root root 0000000 0000000
-- migrate:up
CREATE TABLE tbl_2 (col INT); atlas-0.7.2/cmd/atlas/internal/cmdapi/testdata/import/dbmate_gold/ 0000775 0000000 0000000 00000000000 14314555116 0025135 5 ustar 00root root 0000000 0000000 atlas-0.7.2/cmd/atlas/internal/cmdapi/testdata/import/dbmate_gold/1_initial.sql 0000664 0000000 0000000 00000000440 14314555116 0027525 0 ustar 00root root 0000000 0000000 CREATE TABLE post
(
id int NOT NULL,
title text,
body text,
PRIMARY KEY (id)
);
/*
Multiline comment ...
*/
ALTER TABLE post ADD created_at TIMESTAMP NOT NULL;
-- Normal comment
-- With a second line
INSERT INTO post (title) VALUES (
'This is
my multiline
value');
atlas-0.7.2/cmd/atlas/internal/cmdapi/testdata/import/dbmate_gold/2_second_migration.sql 0000664 0000000 0000000 00000000036 14314555116 0031422 0 ustar 00root root 0000000 0000000 CREATE TABLE tbl_2 (col INT);
atlas-0.7.2/cmd/atlas/internal/cmdapi/testdata/import/flyway/ 0000775 0000000 0000000 00000000000 14314555116 0024207 5 ustar 00root root 0000000 0000000 atlas-0.7.2/cmd/atlas/internal/cmdapi/testdata/import/flyway/B2__baseline.sql 0000664 0000000 0000000 00000000333 14314555116 0027173 0 ustar 00root root 0000000 0000000 CREATE TABLE post
(
id int NOT NULL,
title text,
body text,
created_at TIMESTAMP NOT NULL
PRIMARY KEY (id)
);
INSERT INTO post (title, created_at) VALUES (
'This is
my multiline
value', NOW()); atlas-0.7.2/cmd/atlas/internal/cmdapi/testdata/import/flyway/R__views.sql 0000664 0000000 0000000 00000000056 14314555116 0026506 0 ustar 00root root 0000000 0000000 CREATE VIEW `my_view` AS SELECT * FROM `post`; atlas-0.7.2/cmd/atlas/internal/cmdapi/testdata/import/flyway/U1__initial.sql 0000664 0000000 0000000 00000000017 14314555116 0027063 0 ustar 00root root 0000000 0000000 DROP TABLE tbl; atlas-0.7.2/cmd/atlas/internal/cmdapi/testdata/import/flyway/V1__initial.sql 0000664 0000000 0000000 00000000372 14314555116 0027070 0 ustar 00root root 0000000 0000000 -- comment
CREATE TABLE post
(
id int NOT NULL,
title text,
body text,
PRIMARY KEY (id)
);
ALTER TABLE post ADD created_at TIMESTAMP NOT NULL;
INSERT INTO post (title, created_at) VALUES (
'This is
my multiline
value', NOW());
atlas-0.7.2/cmd/atlas/internal/cmdapi/testdata/import/flyway/V2__second_migration.sql 0000664 0000000 0000000 00000000062 14314555116 0030760 0 ustar 00root root 0000000 0000000
-- migrate:up
CREATE TABLE tbl_2 (col INT); atlas-0.7.2/cmd/atlas/internal/cmdapi/testdata/import/flyway/V3__third_migration.sql 0000664 0000000 0000000 00000000055 14314555116 0030622 0 ustar 00root root 0000000 0000000 ALTER TABLE tbl_2 ADD col_1 INTEGER NOT NULL; atlas-0.7.2/cmd/atlas/internal/cmdapi/testdata/import/flyway_gold/ 0000775 0000000 0000000 00000000000 14314555116 0025214 5 ustar 00root root 0000000 0000000 atlas-0.7.2/cmd/atlas/internal/cmdapi/testdata/import/flyway_gold/2_baseline.sql 0000664 0000000 0000000 00000000333 14314555116 0027737 0 ustar 00root root 0000000 0000000 CREATE TABLE post
(
id int NOT NULL,
title text,
body text,
created_at TIMESTAMP NOT NULL
PRIMARY KEY (id)
);
INSERT INTO post (title, created_at) VALUES (
'This is
my multiline
value', NOW());
atlas-0.7.2/cmd/atlas/internal/cmdapi/testdata/import/flyway_gold/3R_views.sql 0000664 0000000 0000000 00000000057 14314555116 0027440 0 ustar 00root root 0000000 0000000 CREATE VIEW `my_view` AS SELECT * FROM `post`;
atlas-0.7.2/cmd/atlas/internal/cmdapi/testdata/import/flyway_gold/3_third_migration.sql 0000664 0000000 0000000 00000000056 14314555116 0031343 0 ustar 00root root 0000000 0000000 ALTER TABLE tbl_2 ADD col_1 INTEGER NOT NULL;
atlas-0.7.2/cmd/atlas/internal/cmdapi/testdata/import/golang-migrate/ 0000775 0000000 0000000 00000000000 14314555116 0025571 5 ustar 00root root 0000000 0000000 atlas-0.7.2/cmd/atlas/internal/cmdapi/testdata/import/golang-migrate/1_initial.down.sql 0000664 0000000 0000000 00000000017 14314555116 0031127 0 ustar 00root root 0000000 0000000 DROP TABLE tbl; atlas-0.7.2/cmd/atlas/internal/cmdapi/testdata/import/golang-migrate/1_initial.up.sql 0000664 0000000 0000000 00000000041 14314555116 0030601 0 ustar 00root root 0000000 0000000 CREATE TABLE tbl
(
col INT
); atlas-0.7.2/cmd/atlas/internal/cmdapi/testdata/import/golang-migrate/2_second_migration.down.sql 0000664 0000000 0000000 00000000021 14314555116 0033016 0 ustar 00root root 0000000 0000000 DROP TABLE tbl_2; atlas-0.7.2/cmd/atlas/internal/cmdapi/testdata/import/golang-migrate/2_second_migration.up.sql 0000664 0000000 0000000 00000000035 14314555116 0032500 0 ustar 00root root 0000000 0000000 CREATE TABLE tbl_2 (col INT); atlas-0.7.2/cmd/atlas/internal/cmdapi/testdata/import/golang-migrate_gold/ 0000775 0000000 0000000 00000000000 14314555116 0026576 5 ustar 00root root 0000000 0000000 atlas-0.7.2/cmd/atlas/internal/cmdapi/testdata/import/golang-migrate_gold/1_initial.sql 0000664 0000000 0000000 00000000042 14314555116 0031164 0 ustar 00root root 0000000 0000000 CREATE TABLE tbl
(
col INT
);
atlas-0.7.2/cmd/atlas/internal/cmdapi/testdata/import/golang-migrate_gold/2_second_migration.sql 0000664 0000000 0000000 00000000036 14314555116 0033063 0 ustar 00root root 0000000 0000000 CREATE TABLE tbl_2 (col INT);
atlas-0.7.2/cmd/atlas/internal/cmdapi/testdata/import/goose/ 0000775 0000000 0000000 00000000000 14314555116 0024010 5 ustar 00root root 0000000 0000000 atlas-0.7.2/cmd/atlas/internal/cmdapi/testdata/import/goose/1_initial.sql 0000664 0000000 0000000 00000000411 14314555116 0026376 0 ustar 00root root 0000000 0000000 -- +goose Up
CREATE TABLE post
(
id int NOT NULL,
title text,
body text,
PRIMARY KEY (id)
);
ALTER TABLE post ADD created_at TIMESTAMP NOT NULL;
INSERT INTO post (title) VALUES (
'This is
my multiline
value');
-- +goose Down
DROP TABLE post; atlas-0.7.2/cmd/atlas/internal/cmdapi/testdata/import/goose/2_second_migration.sql 0000664 0000000 0000000 00000001437 14314555116 0030303 0 ustar 00root root 0000000 0000000
-- +goose Up
ALTER TABLE post ADD updated_at TIMESTAMP NOT NULL;
-- +goose StatementBegin
-- Comment for the function declaration.
CREATE
OR REPLACE FUNCTION histories_partition_creation( DATE, DATE )
returns void AS $$
DECLARE
create_query text;
BEGIN
FOR create_query IN
SELECT 'CREATE TABLE IF NOT EXISTS histories_'
|| TO_CHAR(d, 'YYYY_MM')
|| ' ( CHECK( created_at >= timestamp '''
|| TO_CHAR(d, 'YYYY-MM-DD 00:00:00')
|| ''' AND created_at < timestamp '''
|| TO_CHAR(d + INTERVAL '1 month', 'YYYY-MM-DD 00:00:00')
|| ''' ) ) inherits ( histories );'
FROM generate_series($1, $2, '1 month') AS d LOOP
EXECUTE create_query;
END LOOP; -- LOOP END
END; -- FUNCTION END
$$
language plpgsql;
-- +goose StatementEnd atlas-0.7.2/cmd/atlas/internal/cmdapi/testdata/import/goose_gold/ 0000775 0000000 0000000 00000000000 14314555116 0025015 5 ustar 00root root 0000000 0000000 atlas-0.7.2/cmd/atlas/internal/cmdapi/testdata/import/goose_gold/1_initial.sql 0000664 0000000 0000000 00000000332 14314555116 0027405 0 ustar 00root root 0000000 0000000 CREATE TABLE post
(
id int NOT NULL,
title text,
body text,
PRIMARY KEY (id)
);
ALTER TABLE post ADD created_at TIMESTAMP NOT NULL;
INSERT INTO post (title) VALUES (
'This is
my multiline
value');
atlas-0.7.2/cmd/atlas/internal/cmdapi/testdata/import/goose_gold/2_second_migration.sql 0000664 0000000 0000000 00000001335 14314555116 0031305 0 ustar 00root root 0000000 0000000 ALTER TABLE post ADD updated_at TIMESTAMP NOT NULL;
-- Comment for the function declaration.
CREATE
OR REPLACE FUNCTION histories_partition_creation( DATE, DATE )
returns void AS $$
DECLARE
create_query text;
BEGIN
FOR create_query IN
SELECT 'CREATE TABLE IF NOT EXISTS histories_'
|| TO_CHAR(d, 'YYYY_MM')
|| ' ( CHECK( created_at >= timestamp '''
|| TO_CHAR(d, 'YYYY-MM-DD 00:00:00')
|| ''' AND created_at < timestamp '''
|| TO_CHAR(d + INTERVAL '1 month', 'YYYY-MM-DD 00:00:00')
|| ''' ) ) inherits ( histories );'
FROM generate_series($1, $2, '1 month') AS d LOOP
EXECUTE create_query;
END LOOP; -- LOOP END
END; -- FUNCTION END
$$
language plpgsql;
atlas-0.7.2/cmd/atlas/internal/cmdapi/testdata/import/liquibase/ 0000775 0000000 0000000 00000000000 14314555116 0024652 5 ustar 00root root 0000000 0000000 atlas-0.7.2/cmd/atlas/internal/cmdapi/testdata/import/liquibase/1_initial.sql 0000664 0000000 0000000 00000000604 14314555116 0027244 0 ustar 00root root 0000000 0000000 --liquibase formatted sql
--changeset atlas:1-1
CREATE TABLE post
(
id int NOT NULL,
title text,
body text,
PRIMARY KEY (id)
);
--rollback: DROP TABLE post;
--changeset atlas:1-2
ALTER TABLE post ADD created_at TIMESTAMP NOT NULL;
--rollback: ALTER TABLE post DROP created_at;
--changeset atlas:1-3
INSERT INTO post (title) VALUES (
'This is
my multiline
value');
atlas-0.7.2/cmd/atlas/internal/cmdapi/testdata/import/liquibase/2_second_migration.sql 0000664 0000000 0000000 00000000154 14314555116 0031140 0 ustar 00root root 0000000 0000000 --liquibase formatted sql
--changeset atlas:2-1
CREATE TABLE tbl_2 (col INT);
--rollback DROP TABLE tbl_2;
atlas-0.7.2/cmd/atlas/internal/cmdapi/testdata/import/liquibase_gold/ 0000775 0000000 0000000 00000000000 14314555116 0025657 5 ustar 00root root 0000000 0000000 atlas-0.7.2/cmd/atlas/internal/cmdapi/testdata/import/liquibase_gold/1_initial.sql 0000664 0000000 0000000 00000000434 14314555116 0030252 0 ustar 00root root 0000000 0000000 --changeset atlas:1-1
CREATE TABLE post
(
id int NOT NULL,
title text,
body text,
PRIMARY KEY (id)
);
--changeset atlas:1-2
ALTER TABLE post ADD created_at TIMESTAMP NOT NULL;
--changeset atlas:1-3
INSERT INTO post (title) VALUES (
'This is
my multiline
value');
atlas-0.7.2/cmd/atlas/internal/cmdapi/testdata/import/liquibase_gold/2_second_migration.sql 0000664 0000000 0000000 00000000064 14314555116 0032145 0 ustar 00root root 0000000 0000000 --changeset atlas:2-1
CREATE TABLE tbl_2 (col INT);
atlas-0.7.2/cmd/atlas/internal/cmdapi/testdata/mysql/ 0000775 0000000 0000000 00000000000 14314555116 0022527 5 ustar 00root root 0000000 0000000 atlas-0.7.2/cmd/atlas/internal/cmdapi/testdata/mysql/20220318104614_initial.sql 0000664 0000000 0000000 00000000264 14314555116 0026344 0 ustar 00root root 0000000 0000000 -- add new schema named "atlantis"
CREATE DATABASE `atlantis`;
-- create "tbl" table
CREATE TABLE `atlantis`.`tbl` (`col` int NOT NULL) CHARSET utf8mb4 COLLATE utf8mb4_general_ci;
atlas-0.7.2/cmd/atlas/internal/cmdapi/testdata/mysql/20220420213403_second.sql 0000664 0000000 0000000 00000000057 14314555116 0026155 0 ustar 00root root 0000000 0000000 ALTER TABLE `atlantis`.`tbl` ADD `col_2` TEXT;
atlas-0.7.2/cmd/atlas/internal/cmdapi/testdata/mysql/atlas.sum 0000664 0000000 0000000 00000000305 14314555116 0024357 0 ustar 00root root 0000000 0000000 h1:EGX5/CEEerpLWqYQNHB1veTXon8t05wEGJiX2fOtFXg=
20220318104614_initial.sql h1:EoDHPlX7fTGn5qiCdR5xhwFh+DrOi3cQ7Y49BsIy97k=
20220420213403_second.sql h1:cAioQjDgJkOIiMAyEwqaurPs0EHpTeu0CnWlJzNj5SE=
atlas-0.7.2/cmd/atlas/internal/cmdapi/testdata/sqlite/ 0000775 0000000 0000000 00000000000 14314555116 0022663 5 ustar 00root root 0000000 0000000 atlas-0.7.2/cmd/atlas/internal/cmdapi/testdata/sqlite/20220318104614_initial.sql 0000664 0000000 0000000 00000000075 14314555116 0026500 0 ustar 00root root 0000000 0000000 -- create "tbl" table
CREATE TABLE tbl (`col` int NOT NULL);
atlas-0.7.2/cmd/atlas/internal/cmdapi/testdata/sqlite/20220318104615_second.sql 0000664 0000000 0000000 00000000046 14314555116 0026321 0 ustar 00root root 0000000 0000000 ALTER TABLE `tbl` ADD `col_2` bigint;
atlas-0.7.2/cmd/atlas/internal/cmdapi/testdata/sqlite/atlas.sum 0000664 0000000 0000000 00000000305 14314555116 0024513 0 ustar 00root root 0000000 0000000 h1:GMi7mvWSIHv0I/Wrc2NCGVt9Z5hWZbPa6wL986t7Z2o=
20220318104614_initial.sql h1:FifWjY2X0g2YVnb18Qm+QBPvoldDOOob7bS0LrFuCXc=
20220318104615_second.sql h1:wbPDlODOQeixCiopAhlT7W4xOO9TgJxzjYjxf4TA2f4=
atlas-0.7.2/cmd/atlas/internal/cmdapi/testdata/sqlite2/ 0000775 0000000 0000000 00000000000 14314555116 0022745 5 ustar 00root root 0000000 0000000 atlas-0.7.2/cmd/atlas/internal/cmdapi/testdata/sqlite2/20220318104614_initial.sql 0000664 0000000 0000000 00000000075 14314555116 0026562 0 ustar 00root root 0000000 0000000 -- create "tbl" table
CREATE TABLE tbl (`col` int NOT NULL);
atlas-0.7.2/cmd/atlas/internal/cmdapi/testdata/sqlite2/20220318104615_second.sql 0000664 0000000 0000000 00000000206 14314555116 0026401 0 ustar 00root root 0000000 0000000 ALTER TABLE `tbl` ADD `col_2` bigint;
asdasd ALTER TABLE `tbl` ADD `col_3` bigint; -- will fail
ALTER TABLE `tbl` ADD `col_4` bigint;
atlas-0.7.2/cmd/atlas/internal/cmdapi/testdata/sqlite2/atlas.sum 0000664 0000000 0000000 00000000305 14314555116 0024575 0 ustar 00root root 0000000 0000000 h1:lXdG49p5Vr5b9eARNKq3Gkgd+flbQXDM+XDyB6b2nzw=
20220318104614_initial.sql h1:FifWjY2X0g2YVnb18Qm+QBPvoldDOOob7bS0LrFuCXc=
20220318104615_second.sql h1:UA1TOODS2yU138E2HBlChe/O8vSmTRxkHs4OJOUK3K8=
atlas-0.7.2/cmd/atlas/internal/cmdapi/testdata/sqlitetx/ 0000775 0000000 0000000 00000000000 14314555116 0023237 5 ustar 00root root 0000000 0000000 atlas-0.7.2/cmd/atlas/internal/cmdapi/testdata/sqlitetx/20220925092817_initial.sql 0000664 0000000 0000000 00000000154 14314555116 0027071 0 ustar 00root root 0000000 0000000 -- create "users" table
CREATE TABLE `users` (`id` integer NOT NULL, `name` text NULL, PRIMARY KEY (`id`));
atlas-0.7.2/cmd/atlas/internal/cmdapi/testdata/sqlitetx/20220925094021_second.sql 0000664 0000000 0000000 00000000716 14314555116 0026704 0 ustar 00root root 0000000 0000000 -- create "friendships" table
CREATE TABLE `friendships` (`user_id` integer NOT NULL, `friend_id` integer NOT NULL, PRIMARY KEY (`user_id`, `friend_id`), CONSTRAINT `user_id_fk` FOREIGN KEY (`user_id`) REFERENCES `users` (`id`) ON DELETE CASCADE, CONSTRAINT `friend_id_fk` FOREIGN KEY (`friend_id`) REFERENCES `users` (`id`) ON DELETE CASCADE);
INSERT INTO `users` (`id`) VALUES (1), (2);
INSERT INTO `friendships` (`user_id`, `friend_id`) VALUES (1,2), (2,1);
atlas-0.7.2/cmd/atlas/internal/cmdapi/testdata/sqlitetx/20220925094437_third.sql 0000664 0000000 0000000 00000001042 14314555116 0026547 0 ustar 00root root 0000000 0000000 -- disable the enforcement of foreign-keys constraints
PRAGMA foreign_keys = off;
-- create "new_users" table
CREATE TABLE `new_users` (`id` integer NOT NULL, PRIMARY KEY (`id`));
-- copy rows from old table "users" to new temporary table "new_users"
INSERT INTO `new_users` (`id`) SELECT `id` FROM `users`;
-- drop "users" table after copying rows
DROP TABLE `users`;
-- rename temporary table "new_users" to "users"
ALTER TABLE `new_users` RENAME TO `users`;
-- enable back the enforcement of foreign-keys constraints
PRAGMA foreign_keys = on;
atlas-0.7.2/cmd/atlas/internal/cmdapi/testdata/sqlitetx/atlas.sum 0000664 0000000 0000000 00000000416 14314555116 0025072 0 ustar 00root root 0000000 0000000 h1:09lkmQGTxdoqPwK0ZXtU4+KHipufkVp1Jlje3t6Opy4=
20220925092817_initial.sql h1:ZGeLdeqNUMXqJm+hPkhBrhzbtUzSBH8yVTsnSnJo/qU=
20220925094021_second.sql h1:vcoquz3yk+TlTPiQgW5hHpS/abIvySCM/bzgwYTDoqY=
20220925094437_third.sql h1:2pbBiUBKsEC5+ppfPPTDr+iwJSgZ2rM4qmHI44/vmnc=
atlas-0.7.2/cmd/atlas/internal/cmdapi/testdata/sqlitetx_2/ 0000775 0000000 0000000 00000000000 14314555116 0023460 5 ustar 00root root 0000000 0000000 atlas-0.7.2/cmd/atlas/internal/cmdapi/testdata/sqlitetx_2/20220925092817_initial.sql 0000664 0000000 0000000 00000000154 14314555116 0027312 0 ustar 00root root 0000000 0000000 -- create "users" table
CREATE TABLE `users` (`id` integer NOT NULL, `name` text NULL, PRIMARY KEY (`id`));
atlas-0.7.2/cmd/atlas/internal/cmdapi/testdata/sqlitetx_2/20220925094021_second.sql 0000664 0000000 0000000 00000000716 14314555116 0027125 0 ustar 00root root 0000000 0000000 -- create "friendships" table
CREATE TABLE `friendships` (`user_id` integer NOT NULL, `friend_id` integer NOT NULL, PRIMARY KEY (`user_id`, `friend_id`), CONSTRAINT `user_id_fk` FOREIGN KEY (`user_id`) REFERENCES `users` (`id`) ON DELETE CASCADE, CONSTRAINT `friend_id_fk` FOREIGN KEY (`friend_id`) REFERENCES `users` (`id`) ON DELETE CASCADE);
INSERT INTO `users` (`id`) VALUES (1), (2);
INSERT INTO `friendships` (`user_id`, `friend_id`) VALUES (1,2), (2,1);
atlas-0.7.2/cmd/atlas/internal/cmdapi/testdata/sqlitetx_2/20220925094437_third.sql 0000664 0000000 0000000 00000001171 14314555116 0026773 0 ustar 00root root 0000000 0000000 -- disable the enforcement of foreign-keys constraints
PRAGMA foreign_keys = off;
-- create "new_users" table
CREATE TABLE `new_users` (`id` integer NOT NULL, PRIMARY KEY (`id`));
-- copy rows from old table "users" to new temporary table "new_users"
INSERT INTO `new_users` (`id`) SELECT `id` FROM `users`;
-- drop "users" table after copying rows
DROP TABLE `users`;
-- rename temporary table "new_users" to "users"
ALTER TABLE `new_users` RENAME TO `users`;
-- insert faulty data
INSERT INTO `friendships` (`user_id`, `friend_id`) VALUES (3,2);
-- enable back the enforcement of foreign-keys constraints
PRAGMA foreign_keys = on;
atlas-0.7.2/cmd/atlas/internal/cmdapi/testdata/sqlitetx_2/atlas.sum 0000664 0000000 0000000 00000000416 14314555116 0025313 0 ustar 00root root 0000000 0000000 h1:eH+7c2mVWbrhky00/3SKYklyHLyz+QzDk1UZJ9+ZJsg=
20220925092817_initial.sql h1:ZGeLdeqNUMXqJm+hPkhBrhzbtUzSBH8yVTsnSnJo/qU=
20220925094021_second.sql h1:vcoquz3yk+TlTPiQgW5hHpS/abIvySCM/bzgwYTDoqY=
20220925094437_third.sql h1:58glD96PVBa0fSu8x/3Gbwbf7N6WjAcVl4jh/XcNXoM=
atlas-0.7.2/cmd/atlas/internal/docker/ 0000775 0000000 0000000 00000000000 14314555116 0017563 5 ustar 00root root 0000000 0000000 atlas-0.7.2/cmd/atlas/internal/docker/docker.go 0000664 0000000 0000000 00000017515 14314555116 0021372 0 ustar 00root root 0000000 0000000 // Copyright 2021-present The Atlas Authors. All rights reserved.
// This source code is licensed under the Apache 2.0 license found
// in the LICENSE file in the root directory of this source tree.
package docker
import (
"bytes"
"context"
"errors"
"fmt"
"io"
"io/ioutil"
"log"
"net"
"net/url"
"os"
"os/exec"
"strconv"
"strings"
"time"
"ariga.io/atlas/sql/sqlclient"
"github.com/go-sql-driver/mysql"
)
const pass = "pass"
type (
// Config is used to configure container creation.
Config struct {
setup []string // contains statements to execute once the service is up
// Image is the name of the image to pull and run.
Image string
// Env vars to pass to the docker container.
Env []string
// Internal Port to expose anc connect to.
Port string
// Out is a custom writer to send docker cli output to.
Out io.Writer
}
// A Container is an instance of a created container.
Container struct {
cfg Config // Config used to create this container
out io.Writer // custom write to log status messages to
// ID of the container.
ID string
// Passphrase of the root user.
Passphrase string
// Port on the host this containers service is bound to.
Port string
}
// ConfigOption allows configuring Config with functional arguments.
ConfigOption func(*Config) error
)
// NewConfig returns a new config with the given options applied.
func NewConfig(opts ...ConfigOption) (*Config, error) {
c := &Config{Out: ioutil.Discard}
for _, opt := range opts {
if err := opt(c); err != nil {
return nil, err
}
}
return c, nil
}
// MySQL returns a new Config for a MySQL image.
func MySQL(version string, opts ...ConfigOption) (*Config, error) {
return NewConfig(
append(
[]ConfigOption{
Image("mysql:" + version),
Port("3306"),
Env("MYSQL_ROOT_PASSWORD=" + pass),
},
opts...,
)...,
)
}
// MariaDB returns a new Config for a MariaDB image.
func MariaDB(version string, opts ...ConfigOption) (*Config, error) {
return MySQL(version, append([]ConfigOption{Image("mariadb:" + version)}, opts...)...)
}
// PostgreSQL returns a new Config for a PostgreSQL image.
func PostgreSQL(version string, opts ...ConfigOption) (*Config, error) {
return NewConfig(
append(
[]ConfigOption{
Image("postgres:" + version),
Port("5432"),
Env("POSTGRES_PASSWORD=" + pass),
},
opts...,
)...,
)
}
// Image sets the docker image to use. For example:
//
// Image("mysql")
// Image("postgres:13")
func Image(i string) ConfigOption {
return func(c *Config) error {
c.Image = strings.TrimSuffix(i, ":")
return nil
}
}
// Port sets the port the container services exposes. For example:
//
// Port("3306")
// Port("5432")
func Port(p string) ConfigOption {
return func(c *Config) error {
c.Port = p
return nil
}
}
// Env sets the environment variables to pass to the container. For example:
//
// Config(Image("mysql"), Env("MYSQL_ROOT_PASSWORD=password"))
// Config(Image("postgres"), Env("MYSQL_ROOT_PASSWORD=password"))
func Env(env ...string) ConfigOption {
return func(c *Config) error {
c.Env = env
return nil
}
}
// Out sets an io.Writer to use when running docker commands. For example:
//
// buf := new(bytes.Buffer)
// NewConfig(Out(buf))
func Out(w io.Writer) ConfigOption {
return func(c *Config) error {
c.Out = w
return nil
}
}
// setup adds statements to execute once the service is ready. For example:
//
// setup("DROP SCHEMA IF EXISTS public CASCADE;")
func setup(s ...string) ConfigOption {
return func(c *Config) error {
c.setup = s
return nil
}
}
// Run pulls and starts a new docker container from the Config.
func (c *Config) Run(ctx context.Context) (*Container, error) {
// Make sure the configuration is not missing critical values.
if err := c.validate(); err != nil {
return nil, err
}
// Get a free host TCP port the container can bind its exposed service port on.
p, err := freePort()
if err != nil {
return nil, fmt.Errorf("getting open port: %w", err)
}
// Make sure the image is up-to-date.
cmd := exec.CommandContext(ctx, "docker", "pull", c.Image) //nolint:gosec
cmd.Stdout = c.Out
if err := cmd.Run(); err != nil {
return nil, fmt.Errorf("pulling image: %w", err)
}
// Run the container.
args := []string{"docker", "run", "--rm", "--detach"}
for _, e := range c.Env {
args = append(args, "-e", e)
}
args = append(args, "-p", fmt.Sprintf("%s:%s", p, c.Port), c.Image)
cmd = exec.CommandContext(ctx, args[0], args[1:]...) //nolint:gosec
out := &bytes.Buffer{}
cmd.Stdout = io.MultiWriter(c.Out, out)
if err := cmd.Run(); err != nil {
return nil, err
}
return &Container{
cfg: *c,
ID: strings.TrimSpace(out.String()),
Passphrase: pass,
Port: p,
out: c.Out,
}, nil
}
// Close stops and removes this container.
func (c *Container) Close() error {
return exec.Command("docker", "stop", c.ID).Run() //nolint:gosec
}
// Wait waits for this container to be ready.
func (c *Container) Wait(ctx context.Context, timeout time.Duration) error {
fmt.Fprintln(c.out, "Waiting for service to be ready ... ")
mysql.SetLogger(log.New(io.Discard, "", 1))
defer mysql.SetLogger(log.New(os.Stderr, "[mysql] ", log.Ldate|log.Ltime|log.Lshortfile))
if timeout > time.Minute {
timeout = time.Minute
}
var (
done = time.After(timeout)
u, err = c.URL()
)
if err != nil {
return err
}
for {
select {
case <-time.After(100 * time.Millisecond):
client, err := sqlclient.Open(ctx, u)
if err != nil {
continue
}
db := client.DB
if err := db.PingContext(ctx); err != nil {
continue
}
for _, s := range c.cfg.setup {
if _, err := db.ExecContext(ctx, s); err != nil {
_ = db.Close()
return fmt.Errorf("%q: %w", s, err)
}
}
_ = db.Close()
fmt.Fprintln(c.out, "Service is ready to connect!")
return nil
case <-ctx.Done():
return ctx.Err()
case <-done:
return errors.New("timeout")
}
}
}
// URL returns a URL to connect to the Container.
func (c *Container) URL() (string, error) {
switch img := strings.SplitN(c.cfg.Image, ":", 2)[0]; img {
case "postgres":
return fmt.Sprintf("postgres://postgres:%s@localhost:%s/postgres?sslmode=disable", c.Passphrase, c.Port), nil
case "mysql", "mariadb":
return fmt.Sprintf("%s://root:%s@localhost:%s/", img, c.Passphrase, c.Port), nil
default:
return "", fmt.Errorf("unknown container image: %q", img)
}
}
// validate that no empty values are given.
func (c *Config) validate() error {
if c == nil || c.Image == "" || c.Port == "" || c.Out == nil {
return fmt.Errorf("invalid configuration %q", c)
}
return nil
}
func freePort() (string, error) {
a, err := net.ResolveTCPAddr("tcp", ":0")
if err != nil {
return "", err
}
l, err := net.ListenTCP("tcp", a)
if err != nil {
return "", err
}
if err := l.Close(); err != nil {
return "", err
}
return strconv.Itoa(l.Addr().(*net.TCPAddr).Port), nil
}
func init() {
sqlclient.Register("docker", sqlclient.OpenerFunc(client))
}
func client(ctx context.Context, u *url.URL) (client *sqlclient.Client, err error) {
var cfg *Config
switch img, tag := u.Host, strings.TrimPrefix(u.Path, "/"); img {
case "mysql":
cfg, err = MySQL(tag)
case "mariadb":
cfg, err = MariaDB(tag)
case "postgres":
cfg, err = PostgreSQL(tag)
default:
return nil, fmt.Errorf("unsupported docker image %q", img)
}
if err != nil {
return nil, err
}
if u.Query().Has("v") || u.Query().Has("verbose") {
if err := Out(os.Stdout)(cfg); err != nil {
return nil, err
}
}
c, err := cfg.Run(ctx)
if err != nil {
return nil, err
}
defer func() {
if err != nil {
if cerr := c.Close(); err != nil {
err = fmt.Errorf("%w: %v", err, cerr)
}
}
}()
if err = c.Wait(ctx, time.Minute); err != nil {
return nil, err
}
u1, err := c.URL()
if err != nil {
return nil, err
}
if client, err = sqlclient.Open(ctx, u1); err != nil {
return nil, err
}
client.AddClosers(c)
return client, nil
}
atlas-0.7.2/cmd/atlas/internal/docker/docker_test.go 0000664 0000000 0000000 00000002163 14314555116 0022422 0 ustar 00root root 0000000 0000000 // Copyright 2021-present The Atlas Authors. All rights reserved.
// This source code is licensed under the Apache 2.0 license found
// in the LICENSE file in the root directory of this source tree.
package docker
import (
"context"
"io"
"testing"
"github.com/stretchr/testify/require"
)
func TestDockerConfig(t *testing.T) {
ctx := context.Background()
// invalid config
_, err := (&Config{}).Run(ctx)
require.Error(t, err)
// MySQL
cfg, err := MySQL("latest", Out(io.Discard))
require.NoError(t, err)
require.Equal(t, &Config{
Image: "mysql:latest",
Env: []string{"MYSQL_ROOT_PASSWORD=pass"},
Port: "3306",
Out: io.Discard,
}, cfg)
// MariaDB
cfg, err = MariaDB("latest", Out(io.Discard))
require.NoError(t, err)
require.Equal(t, &Config{
Image: "mariadb:latest",
Env: []string{"MYSQL_ROOT_PASSWORD=pass"},
Port: "3306",
Out: io.Discard,
}, cfg)
// PostgreSQL
cfg, err = PostgreSQL("latest", Out(io.Discard))
require.NoError(t, err)
require.Equal(t, &Config{
Image: "postgres:latest",
Env: []string{"POSTGRES_PASSWORD=pass"},
Port: "5432",
Out: io.Discard,
}, cfg)
}
atlas-0.7.2/cmd/atlas/internal/lint/ 0000775 0000000 0000000 00000000000 14314555116 0017262 5 ustar 00root root 0000000 0000000 atlas-0.7.2/cmd/atlas/internal/lint/lint.go 0000664 0000000 0000000 00000022030 14314555116 0020554 0 ustar 00root root 0000000 0000000 // Copyright 2021-present The Atlas Authors. All rights reserved.
// This source code is licensed under the Apache 2.0 license found
// in the LICENSE file in the root directory of this source tree.
package lint
import (
"context"
"errors"
"fmt"
"os/exec"
"path/filepath"
"strings"
"ariga.io/atlas/cmd/atlas/internal/sqlparse"
"ariga.io/atlas/sql/migrate"
"ariga.io/atlas/sql/schema"
"ariga.io/atlas/sql/sqlcheck"
"ariga.io/atlas/sql/sqlclient"
)
type (
// A ChangeDetector takes a migration directory and splits it into the "base" files (already merged) and new ones.
ChangeDetector interface {
// DetectChanges splits the files of a migration directory into the "base" files (already merged) and new ones.
DetectChanges(context.Context) ([]migrate.File, []migrate.File, error)
}
// A ChangeLoader takes a set of migration files and will create multiple schema.Changes out of it.
ChangeLoader interface {
// LoadChanges converts each of the given migration files into one Changes.
LoadChanges(context.Context, []migrate.File) (*Changes, error)
}
// Changes holds schema changes information returned by the loader.
Changes struct {
From, To *schema.Realm // Current and desired schema.
Files []*sqlcheck.File // Files for moving from current to desired state.
}
)
type (
// GitChangeDetector implements the ChangeDetector interface by utilizing a git repository.
GitChangeDetector struct {
work string // path to the git working directory (i.e. -C)
base string // name of the base branch (e.g. master)
path string // path of the migration directory relative to the repository root (in slash notation)
dir migrate.Dir // the migration directory to load migration files from
}
// GitChangeDetectorOption allows configuring GitChangeDetector with functional arguments.
GitChangeDetectorOption func(*GitChangeDetector) error
)
// NewGitChangeDetector configures a new GitChangeDetector.
func NewGitChangeDetector(dir migrate.Dir, opts ...GitChangeDetectorOption) (*GitChangeDetector, error) {
if dir == nil {
return nil, errors.New("internal/ci: dir cannot be nil")
}
d := &GitChangeDetector{dir: dir}
for _, opt := range opts {
if err := opt(d); err != nil {
return nil, err
}
}
if d.base == "" {
d.base = "master"
}
if d.path == "" {
d.path = "migrations"
}
return d, nil
}
// WithWorkDir configures the git working directory for a GitChangeDetector.
func WithWorkDir(work string) GitChangeDetectorOption {
return func(d *GitChangeDetector) error {
d.work = work
return nil
}
}
// WithBase configures the git base branch name for a GitChangeDetector.
func WithBase(base string) GitChangeDetectorOption {
return func(d *GitChangeDetector) error {
d.base = base
return nil
}
}
// WithMigrationsPath configures the path for the migration directory.
func WithMigrationsPath(path string) GitChangeDetectorOption {
return func(d *GitChangeDetector) error {
d.path = filepath.ToSlash(path)
return nil
}
}
// DetectChanges implements the ChangeDetector interface.
func (d *GitChangeDetector) DetectChanges(ctx context.Context) ([]migrate.File, []migrate.File, error) {
if _, err := exec.LookPath("git"); err != nil {
return nil, nil, fmt.Errorf("lookup git: %w", err)
}
var args []string
if d.work != "" {
args = append(args, "-C", d.work)
}
args = append(args, "--no-pager", "diff", "--name-only", "--diff-filter=A", d.base, "HEAD", d.path)
buf, err := exec.CommandContext(ctx, "git", args...).CombinedOutput()
if err != nil {
return nil, nil, fmt.Errorf("git diff: %w", err)
}
diff := strings.Split(string(buf), "\n")
names := make(map[string]struct{}, len(diff))
for i := range diff {
names[filepath.Base(diff[i])] = struct{}{}
}
files, err := d.dir.Files()
if err != nil {
return nil, nil, fmt.Errorf("reading migration directory: %w", err)
}
// Iterate over the migration files. If we find a file, that has been added in the diff between base and head,
// every migration file preceding it can be considered old, the file itself and everything thereafter new,
// since Atlas assumes a linear migration history.
for i, f := range files {
if _, ok := names[f.Name()]; ok {
return files[:i], files[i:], nil
}
}
return files, nil, nil
}
var _ ChangeDetector = (*GitChangeDetector)(nil)
// latestChange implements the ChangeDetector by selecting the latest N files.
type latestChange struct {
n int // number of (latest) files considered new.
dir migrate.Dir // migration directory to load migration files from.
}
// LatestChanges implements the ChangeDetector interface by selecting the latest N files as new.
// It is useful for executing analysis on files in development before they are committed or on
// all files in a directory.
func LatestChanges(dir migrate.Dir, n int) ChangeDetector {
return &latestChange{n: n, dir: dir}
}
// DetectChanges implements the ChangeDetector interface.
func (d *latestChange) DetectChanges(context.Context) ([]migrate.File, []migrate.File, error) {
files, err := d.dir.Files()
if err != nil {
return nil, nil, fmt.Errorf("internal/ci: reading migration directory: %w", err)
}
// In case n is -1 or greater than the
// number of files, return all files.
if len(files) <= d.n || d.n < 0 {
return nil, files, nil
}
return files[:len(files)-d.n], files[len(files)-d.n:], nil
}
// DevLoader implements the ChangesLoader interface using a dev-driver.
type DevLoader struct {
// Dev environment used as a sandbox instantiated to the starting point (e.g. base branch).
Dev *sqlclient.Client
}
// LoadChanges implements the ChangesLoader interface.
func (d *DevLoader) LoadChanges(ctx context.Context, base, files []migrate.File) (diff *Changes, err error) {
unlock, err := d.lock(ctx)
if err != nil {
return nil, err
}
defer unlock()
// Clean up after ourselves.
snap, ok := d.Dev.Driver.(migrate.Snapshoter)
if !ok {
return nil, errors.New("driver does not implement migrate.Snapshoter")
}
restore, err := snap.Snapshot(ctx)
if err != nil {
return nil, fmt.Errorf("taking database snapshot: %w", err)
}
defer func() {
if err2 := restore(ctx); err2 != nil {
if err != nil {
err2 = fmt.Errorf("%w: %v", err, err2)
}
err = err2
}
}()
// Bring the dev environment to the base point.
for _, f := range base {
stmt, err := f.Stmts()
if err != nil {
return nil, &FileError{File: f.Name(), Err: fmt.Errorf("scanning statements: %w", err)}
}
for _, s := range stmt {
if _, err := d.Dev.ExecContext(ctx, s); err != nil {
return nil, &FileError{File: f.Name(), Err: fmt.Errorf("executing statement: %q: %w", s, err)}
}
}
}
current, err := d.inspect(ctx)
if err != nil {
return nil, err
}
diff = &Changes{
From: current,
Files: make([]*sqlcheck.File, len(files)),
}
for i, f := range files {
diff.Files[i] = &sqlcheck.File{
File: f,
Parser: sqlparse.ParserFor(d.Dev.Name),
}
stmts, err := f.StmtDecls()
if err != nil {
return nil, &FileError{File: f.Name(), Err: fmt.Errorf("scanning statements: %w", err)}
}
start := current
for _, s := range stmts {
if _, err := d.Dev.ExecContext(ctx, s.Text); err != nil {
return nil, &FileError{File: f.Name(), Err: fmt.Errorf("executing statement: %w", err)}
}
target, err := d.inspect(ctx)
if err != nil {
return nil, err
}
changes, err := d.Dev.RealmDiff(current, target)
if err != nil {
return nil, err
}
current = target
diff.Files[i].Changes = append(diff.Files[i].Changes, &sqlcheck.Change{
Stmt: s,
Changes: d.mayFix(s.Text, changes),
})
}
if diff.Files[i].Sum, err = d.Dev.RealmDiff(start, current); err != nil {
return nil, err
}
}
diff.To = current
return diff, nil
}
// mayFix uses the sqlparse package for fixing or attaching more info to the changes.
func (d *DevLoader) mayFix(stmt string, changes schema.Changes) schema.Changes {
p := sqlparse.ParserFor(d.Dev.Name)
if p == nil {
return changes
}
if fixed, err := p.FixChange(d.Dev.Driver, stmt, changes); err == nil {
return fixed
}
return changes
}
// inspect the realm and filter by schema if we are connected to one.
func (d *DevLoader) inspect(ctx context.Context) (*schema.Realm, error) {
opts := &schema.InspectRealmOption{}
if d.Dev.URL.Schema != "" {
opts.Schemas = append(opts.Schemas, d.Dev.URL.Schema)
}
return d.Dev.InspectRealm(ctx, opts)
}
// lock database so no one else interferes with our change detection.
func (d *DevLoader) lock(ctx context.Context) (schema.UnlockFunc, error) {
l, ok := d.Dev.Driver.(schema.Locker)
if !ok {
return nil, errors.New("driver does not support locking")
}
name := "atlas_lint"
// In case the client is connected to specific schema,
// minimize the lock resolution to the schema name.
if s := d.Dev.URL.Schema; s != "" {
name = fmt.Sprintf("%s_%s", name, s)
}
unlock, err := l.Lock(ctx, name, 0)
if err != nil {
return nil, fmt.Errorf("acquiring database lock: %w", err)
}
return unlock, nil
}
// FileError represents an error that occurred while processing a file.
type FileError struct {
File string
Err error
}
func (e FileError) Error() string { return e.Err.Error() }
atlas-0.7.2/cmd/atlas/internal/lint/lint_test.go 0000664 0000000 0000000 00000017127 14314555116 0021626 0 ustar 00root root 0000000 0000000 // Copyright 2021-present The Atlas Authors. All rights reserved.
// This source code is licensed under the Apache 2.0 license found
// in the LICENSE file in the root directory of this source tree.
package lint_test
import (
"context"
"io/fs"
"os"
"os/exec"
"path/filepath"
"strconv"
"strings"
"testing"
"time"
"ariga.io/atlas/cmd/atlas/internal/lint"
"ariga.io/atlas/sql/migrate"
"ariga.io/atlas/sql/schema"
"ariga.io/atlas/sql/sqlclient"
_ "ariga.io/atlas/sql/sqlite"
_ "github.com/mattn/go-sqlite3"
"github.com/stretchr/testify/require"
)
func TestGitChangeDetector(t *testing.T) {
// Prepare environment.
root := filepath.Join(t.TempDir(), t.Name(), strconv.FormatInt(time.Now().Unix(), 10))
mdir := filepath.Join(root, "migrations")
require.NoError(t, os.MkdirAll(mdir, 0755))
git := func(args ...string) {
out, err := exec.Command("git", append([]string{"-C", root}, args...)...).CombinedOutput()
require.NoError(t, err, string(out))
}
git("init")
// Config a fake Git user for the working directory.
git("config", "user.name", "a8m")
git("config", "user.email", "a8m@atlasgo.io")
require.NoError(t, os.WriteFile(filepath.Join(mdir, "1_applied.sql"), []byte("1_applied.sql"), 0644))
require.NoError(t, os.WriteFile(filepath.Join(mdir, "2_applied.sql"), []byte("2_applied.sql"), 0644))
git("add", ".")
git("commit", "-m", "applied migrations")
git("checkout", "-b", "feature")
require.NoError(t, os.WriteFile(filepath.Join(mdir, "3_new.sql"), []byte("3_new.sql"), 0644))
require.NoError(t, os.WriteFile(filepath.Join(mdir, "4_new.sql"), []byte("4_new.sql"), 0644))
git("add", ".")
git("commit", "-am", "new migrations")
// Test change detector.
dir, err := migrate.NewLocalDir(mdir)
require.NoError(t, err)
cs, err := lint.NewGitChangeDetector(dir, lint.WithWorkDir(root))
require.NoError(t, err)
base, feat, err := cs.DetectChanges(context.Background())
require.NoError(t, err)
require.Len(t, base, 2)
require.Len(t, feat, 2)
require.Equal(t, "1_applied.sql", base[0].Name())
require.Equal(t, "2_applied.sql", base[1].Name())
require.Equal(t, "3_new.sql", feat[0].Name())
require.Equal(t, "4_new.sql", feat[1].Name())
require.NoError(t, os.WriteFile(filepath.Join(mdir, "5_new.sql"), []byte("5_new.sql"), 0644))
require.NoError(t, os.WriteFile(filepath.Join(mdir, "6_new.sql"), []byte("6_new.sql"), 0644))
git("checkout", "-b", "feature-1")
git("add", ".")
git("commit", "-am", "new migrations")
base, feat, err = cs.DetectChanges(context.Background())
require.NoError(t, err)
require.Len(t, base, 2)
require.Len(t, feat, 4)
require.Equal(t, "5_new.sql", feat[2].Name())
require.Equal(t, "6_new.sql", feat[3].Name())
// Compare feature and feature-1.
cs, err = lint.NewGitChangeDetector(dir, lint.WithWorkDir(root), lint.WithBase("feature"))
require.NoError(t, err)
base, feat, err = cs.DetectChanges(context.Background())
require.NoError(t, err)
require.Len(t, base, 4)
require.Len(t, feat, 2)
require.Equal(t, "1_applied.sql", base[0].Name())
require.Equal(t, "2_applied.sql", base[1].Name())
require.Equal(t, "3_new.sql", base[2].Name())
require.Equal(t, "4_new.sql", base[3].Name())
require.Equal(t, "5_new.sql", feat[0].Name())
require.Equal(t, "6_new.sql", feat[1].Name())
}
func TestLatestChanges(t *testing.T) {
files := []migrate.File{
testFile{name: "1.sql", content: "CREATE TABLE t1 (id INT)"},
testFile{name: "2.sql", content: "CREATE TABLE t2 (id INT)\nDROP TABLE users"},
}
base, feat, err := lint.LatestChanges(testDir{files: files}, 0).DetectChanges(context.Background())
require.NoError(t, err)
require.Equal(t, files, base)
require.Empty(t, feat)
base, feat, err = lint.LatestChanges(testDir{files: files}, 2).DetectChanges(context.Background())
require.NoError(t, err)
require.Empty(t, base)
require.Equal(t, files, feat)
base, feat, err = lint.LatestChanges(testDir{files: files}, -1).DetectChanges(context.Background())
require.NoError(t, err)
require.Empty(t, base)
require.Equal(t, files, feat)
base, feat, err = lint.LatestChanges(testDir{files: files}, 1).DetectChanges(context.Background())
require.NoError(t, err)
require.Equal(t, files[:1], base)
require.Equal(t, files[1:], feat)
}
func TestDevLoader_LoadChanges(t *testing.T) {
ctx := context.Background()
c, err := sqlclient.Open(ctx, "sqlite://ci?mode=memory&cache=shared&_fk=1")
require.NoError(t, err)
defer c.Close()
l := &lint.DevLoader{Dev: c}
diff, err := l.LoadChanges(ctx, nil, nil)
require.NoError(t, err)
require.Empty(t, diff.Files)
base := []migrate.File{
testFile{name: "base.sql", content: "CREATE TABLE users (id INT)"},
}
files := []migrate.File{
testFile{name: "1.sql", content: "CREATE TABLE t1 (id INT)\nINSERT INTO t1 (id) VALUES (1)"},
testFile{name: "2.sql", content: "CREATE TABLE t2 (id INT)\nDROP TABLE users"},
testFile{name: "3.sql", content: "CREATE TABLE t3 (id INT)\nDROP TABLE t3"},
testFile{name: "4.sql", content: "ALTER TABLE t2 RENAME id TO oid"},
}
diff, err = l.LoadChanges(ctx, base, files)
require.NoError(t, err)
require.Len(t, diff.Files, 4)
// File 1.
require.Equal(t, files[0], diff.Files[0].File)
require.Len(t, diff.Files[0].Changes, 2)
require.Zero(t, diff.Files[0].Changes[0].Stmt.Pos)
require.Equal(t, "CREATE TABLE t1 (id INT)", diff.Files[0].Changes[0].Stmt.Text)
require.IsType(t, (*schema.AddTable)(nil), diff.Files[0].Changes[0].Changes[0])
require.Equal(t, "INSERT INTO t1 (id) VALUES (1)", diff.Files[0].Changes[1].Stmt.Text)
require.Empty(t, diff.Files[0].Changes[1].Changes)
// File 2.
require.Equal(t, files[1], diff.Files[1].File)
require.Len(t, diff.Files[1].Changes, 2)
require.Zero(t, diff.Files[1].Changes[0].Stmt.Pos)
require.Equal(t, "CREATE TABLE t2 (id INT)", diff.Files[1].Changes[0].Stmt.Text)
require.IsType(t, (*schema.AddTable)(nil), diff.Files[1].Changes[0].Changes[0])
require.Zero(t, diff.Files[1].Changes[0].Stmt.Pos)
require.Equal(t, "DROP TABLE users", diff.Files[1].Changes[1].Stmt.Text)
require.IsType(t, (*schema.DropTable)(nil), diff.Files[1].Changes[1].Changes[0])
// File 3.
require.Equal(t, files[2], diff.Files[2].File)
require.IsType(t, (*schema.AddTable)(nil), diff.Files[2].Changes[0].Changes[0])
require.IsType(t, (*schema.DropTable)(nil), diff.Files[2].Changes[1].Changes[0])
require.Empty(t, diff.Files[2].Sum)
// File 3.
require.Equal(t, files[3], diff.Files[3].File)
require.IsType(t, (*schema.ModifyTable)(nil), diff.Files[3].Changes[0].Changes[0])
require.IsType(t, (*schema.RenameColumn)(nil), diff.Files[3].Changes[0].Changes[0].(*schema.ModifyTable).Changes[0])
// Changes.
changes, err := c.RealmDiff(diff.From, diff.To)
require.NoError(t, err)
require.Len(t, changes, 3)
err = c.ApplyChanges(ctx, []schema.Change{
&schema.AddTable{
T: schema.NewTable("users").AddColumns(schema.NewIntColumn("id", "int")),
},
})
require.NoError(t, err)
_, err = l.LoadChanges(ctx, base, files)
require.ErrorAs(t, err, &migrate.NotCleanError{})
}
type testDir struct {
migrate.Dir
files []migrate.File
}
func (t testDir) Path() string {
return "migrations"
}
func (t testDir) Open(string) (fs.File, error) {
return nil, fs.ErrNotExist
}
func (t testDir) Files() ([]migrate.File, error) {
return t.files, nil
}
type testFile struct {
migrate.File
name, content string
}
func (f testFile) Name() string {
return f.name
}
func (f testFile) Bytes() []byte {
return []byte(f.content)
}
func (f testFile) Stmts() ([]string, error) {
return strings.Split(string(f.Bytes()), "\n"), nil
}
func (f testFile) StmtDecls() (stmts []*migrate.Stmt, err error) {
s, err := f.Stmts()
if err != nil {
return nil, err
}
for _, s := range s {
stmts = append(stmts, &migrate.Stmt{Text: s})
}
return
}
atlas-0.7.2/cmd/atlas/internal/lint/run.go 0000664 0000000 0000000 00000023753 14314555116 0020427 0 ustar 00root root 0000000 0000000 // Copyright 2021-present The Atlas Authors. All rights reserved.
// This source code is licensed under the Apache 2.0 license found
// in the LICENSE file in the root directory of this source tree.
package lint
import (
"context"
"encoding/json"
"errors"
"fmt"
"io"
"strings"
"text/template"
"ariga.io/atlas/sql/migrate"
"ariga.io/atlas/sql/sqlcheck"
"ariga.io/atlas/sql/sqlclient"
"golang.org/x/exp/slices"
)
// Runner is used to execute CI jobs.
type Runner struct {
// DevClient configures the "dev driver" to calculate
// migration changes by the driver.
Dev *sqlclient.Client
// RunChangeDetector configures the ChangeDetector to
// be used by the runner.
ChangeDetector ChangeDetector
// Dir is used for scanning and validating the migration directory.
Dir migrate.Dir
// Analyzers defines the analysis to be run in the CI job.
Analyzers []sqlcheck.Analyzer
// ReportWriter writes the summary report.
ReportWriter ReportWriter
// summary report. reset on each run.
sum *SummaryReport
}
// Run executes the CI job.
func (r *Runner) Run(ctx context.Context) error {
switch err := r.summary(ctx); err.(type) {
case nil:
if err := r.ReportWriter.WriteReport(r.sum); err != nil {
return err
}
// If any of the analyzers returns
// an error, fail silently.
for _, f := range r.sum.Files {
if f.Error != "" {
return SilentError{}
}
}
return nil
case *FileError:
if err := r.ReportWriter.WriteReport(r.sum); err != nil {
return err
}
return SilentError{error: err}
default:
return err
}
}
const (
stepIntegrityCheck = "Migration Integrity Check"
stepDetectChanges = "Detect New Migration Files"
stepLoadChanges = "Replay Migration Files"
stepAnalyzeFile = "Analyze %s"
)
func (r *Runner) summary(ctx context.Context) error {
r.sum = NewSummaryReport(r.Dev, r.Dir)
// Integrity check.
switch err := migrate.Validate(r.Dir); {
case errors.Is(err, migrate.ErrChecksumNotFound):
case err != nil:
err := &FileError{File: migrate.HashFileName, Err: err}
r.sum.Files = append(r.sum.Files, &FileReport{Name: migrate.HashFileName, Error: err.Error()})
return r.sum.StepError(stepIntegrityCheck, fmt.Sprintf("File %s is invalid", migrate.HashFileName), err)
default:
r.sum.StepResult(stepIntegrityCheck, fmt.Sprintf("File %s is valid", migrate.HashFileName), nil)
}
// Detect new migration files.
base, feat, err := r.ChangeDetector.DetectChanges(ctx)
if err != nil {
return r.sum.StepError(stepDetectChanges, "Failed find new migration files", err)
}
r.sum.StepResult(stepDetectChanges, fmt.Sprintf("Found %d new migration files (from %d total)", len(feat), len(base)+len(feat)), nil)
// Load files into changes.
l := &DevLoader{Dev: r.Dev}
diff, err := l.LoadChanges(ctx, base, feat)
if err != nil {
if fr := (&FileError{}); errors.As(err, &fr) {
r.sum.Files = append(r.sum.Files, &FileReport{Name: fr.File, Error: err.Error()})
}
return r.sum.StepError(stepLoadChanges, "Failed loading changes on dev database", err)
}
r.sum.StepResult(stepLoadChanges, fmt.Sprintf("Loaded %d changes on dev database", len(diff.Files)), nil)
r.sum.WriteSchema(r.Dev, diff)
// Analyze files.
for _, f := range diff.Files {
var (
es []string
nl = nolintRules(f)
fr = NewFileReport(f)
)
for _, az := range r.Analyzers {
if err := az.Analyze(ctx, &sqlcheck.Pass{
File: f,
Dev: r.Dev,
Reporter: nl.reporterFor(fr, az),
}); err != nil && !nl.skipped {
es = append(es, err.Error())
}
}
fr.Error = strings.Join(es, "; ")
r.sum.Files = append(r.sum.Files, fr)
r.sum.StepResult(
fmt.Sprintf(stepAnalyzeFile, f.Name()),
fmt.Sprintf("%d reports were found in analysis", len(fr.Reports)),
fr,
)
}
return nil
}
var (
// TemplateFuncs are global functions available in templates.
TemplateFuncs = template.FuncMap{
"json": func(v any) (string, error) {
b, err := json.Marshal(v)
return string(b), err
},
}
// DefaultTemplate is the default template used by the CI job.
DefaultTemplate = template.Must(template.New("report").
Funcs(TemplateFuncs).
Parse(`
{{- range $f := .Files }}
{{- /* If there is an error but not diagnostics, print it. */}}
{{- if and $f.Error (not $f.Reports) }}
{{- printf "%s: %s\n" $f.Name $f.Error }}
{{- else }}
{{- range $r := $f.Reports }}
{{- if $r.Text }}
{{- printf "%s: %s:\n\n" $f.Name $r.Text }}
{{- else if $r.Diagnostics }}
{{- printf "Unnamed diagnostics for file %s:\n\n" $f.Name }}
{{- end }}
{{- range $d := $r.Diagnostics }}
{{- printf "\tL%d: %s\n" ($f.Line $d.Pos) $d.Text }}
{{- end }}
{{- if $r.Diagnostics }}
{{- print "\n" }}
{{- end }}
{{- end }}
{{- end }}
{{- end -}}
`))
)
type (
// A SummaryReport contains a summary of the analysis of all files.
// It is used as an input to templates to report the CI results.
SummaryReport struct {
// Env holds the environment information.
Env struct {
Driver string `json:"Driver,omitempty"` // Driver name.
URL *sqlclient.URL `json:"URL,omitempty"` // URL to dev database.
Dir string `json:"Dir,omitempty"` // Path to migration directory.
}
// Steps of the analysis. Added in verbose mode.
Steps []struct {
Name string `json:"Name,omitempty"` // Step name.
Text string `json:"Text,omitempty"` // Step description.
Error string `json:"Error,omitempty"` // Error that cause the execution to halt.
Result any `json:"Result,omitempty"` // Result of the step. For example, a diagnostic.
}
// Schema versions found by the runner.
Schema struct {
Current string `json:"Current,omitempty"` // Current schema.
Desired string `json:"Desired,omitempty"` // Desired schema.
}
// Files reports. Non-empty in case there are findings.
Files []*FileReport `json:"Files,omitempty"`
}
// FileReport contains a summary of the analysis of a single file.
FileReport struct {
Name string `json:"Name,omitempty"` // Name of the file.
Text string `json:"Text,omitempty"` // Contents of the file.
Reports []sqlcheck.Report `json:"Reports,omitempty"` // List of reports.
Error string `json:"Error,omitempty"` // File specific error.
}
// ReportWriter is a type of report writer that writes a summary of analysis reports.
ReportWriter interface {
WriteReport(*SummaryReport) error
}
// A TemplateWriter is a type of writer that writes output according to a template.
TemplateWriter struct {
T *template.Template
W io.Writer
}
// SilentError is returned in case the wrapped error is already
// printed by the runner and should not be printed by its caller
SilentError struct{ error }
)
// NewSummaryReport returns a new SummaryReport.
func NewSummaryReport(c *sqlclient.Client, dir migrate.Dir) *SummaryReport {
sum := &SummaryReport{
Env: struct {
Driver string `json:"Driver,omitempty"`
URL *sqlclient.URL `json:"URL,omitempty"`
Dir string `json:"Dir,omitempty"`
}{
Driver: c.Name,
URL: c.URL,
},
Files: make([]*FileReport, 0),
}
if p, ok := dir.(interface{ Path() string }); ok {
sum.Env.Dir = p.Path()
}
return sum
}
// StepResult appends step result to the summary.
func (f *SummaryReport) StepResult(name, text string, result any) {
f.Steps = append(f.Steps, struct {
Name string `json:"Name,omitempty"`
Text string `json:"Text,omitempty"`
Error string `json:"Error,omitempty"`
Result any `json:"Result,omitempty"`
}{
Name: name,
Text: text,
Result: result,
})
}
// StepError appends step error to the summary.
func (f *SummaryReport) StepError(name, text string, err error) error {
f.Steps = append(f.Steps, struct {
Name string `json:"Name,omitempty"`
Text string `json:"Text,omitempty"`
Error string `json:"Error,omitempty"`
Result any `json:"Result,omitempty"`
}{
Name: name,
Text: text,
Error: err.Error(),
})
return err
}
// WriteSchema writes the current and desired schema to the summary.
func (f *SummaryReport) WriteSchema(c *sqlclient.Client, diff *Changes) {
if curr, err := c.MarshalSpec(diff.From); err == nil {
f.Schema.Current = string(curr)
}
if desired, err := c.MarshalSpec(diff.To); err == nil {
f.Schema.Desired = string(desired)
}
}
// NewFileReport returns a new FileReport.
func NewFileReport(f migrate.File) *FileReport {
return &FileReport{Name: f.Name(), Text: string(f.Bytes())}
}
// Line returns the line number from a position.
func (f *FileReport) Line(pos int) int {
return strings.Count(f.Text[:pos], "\n") + 1
}
// WriteReport implements sqlcheck.ReportWriter.
func (f *FileReport) WriteReport(r sqlcheck.Report) {
f.Reports = append(f.Reports, r)
}
// WriteReport implements ReportWriter.
func (w *TemplateWriter) WriteReport(r *SummaryReport) error {
return w.T.Execute(w.W, r)
}
func nolintRules(f *sqlcheck.File) *skipRules {
s := &skipRules{pos2rules: make(map[int][]string)}
for _, c := range f.Changes {
for _, d := range c.Stmt.Directive("nolint") {
s.pos2rules[c.Stmt.Pos] = append(s.pos2rules[c.Stmt.Pos], strings.Split(d, " ")...)
}
}
return s
}
type skipRules struct {
pos2rules map[int][]string // statement positions to rules
skipped bool // last one skipped
}
func (s *skipRules) reporterFor(rw sqlcheck.ReportWriter, az sqlcheck.Analyzer) sqlcheck.ReportWriter {
return sqlcheck.ReportWriterFunc(func(r sqlcheck.Report) {
var (
ds = make([]sqlcheck.Diagnostic, 0, len(r.Diagnostics))
az, ok = az.(sqlcheck.NamedAnalyzer)
)
for _, d := range r.Diagnostics {
switch rules := s.pos2rules[d.Pos]; {
case
// A directive without specific classes/codes
// (e.g. atlas:nolint) ignore all diagnostics.
len(rules) == 1 && rules[0] == "",
// Match a specific code/diagnostic. e.g. atlas:nolint DS101.
slices.Contains(rules, d.Code),
// Skip the entire analyzer (class of changes).
ok && slices.Contains(rules, az.Name()):
default:
ds = append(ds, d)
}
}
if s.skipped = len(ds) == 0; !s.skipped {
rw.WriteReport(sqlcheck.Report{Text: r.Text, Diagnostics: ds})
}
})
}
atlas-0.7.2/cmd/atlas/internal/lint/run_test.go 0000664 0000000 0000000 00000007031 14314555116 0021455 0 ustar 00root root 0000000 0000000 // Copyright 2021-present The Atlas Authors. All rights reserved.
// This source code is licensed under the Apache 2.0 license found
// in the LICENSE file in the root directory of this source tree.
package lint_test
import (
"bytes"
"context"
_ "embed"
"fmt"
"testing"
"text/template"
"ariga.io/atlas/cmd/atlas/internal/lint"
"ariga.io/atlas/sql/migrate"
"ariga.io/atlas/sql/sqlcheck"
"ariga.io/atlas/sql/sqlclient"
"github.com/stretchr/testify/require"
)
func TestRunner_Run(t *testing.T) {
ctx := context.Background()
b := &bytes.Buffer{}
c, err := sqlclient.Open(ctx, "sqlite://run?mode=memory&cache=shared&_fk=1")
require.NoError(t, err)
r := &lint.Runner{
Dir: testDir{},
Dev: c,
ChangeDetector: testDetector{
base: []migrate.File{
testFile{name: "1.sql", content: "CREATE TABLE users (id INT)"},
},
feat: []migrate.File{
testFile{name: "2.sql", content: "CREATE TABLE pets (id INT)\nDROP TABLE users"},
},
},
Analyzers: []sqlcheck.Analyzer{
&testAnalyzer{},
},
ReportWriter: &lint.TemplateWriter{
T: lint.DefaultTemplate,
W: b,
},
}
require.NoError(t, r.Run(ctx))
passes := r.Analyzers[0].(*testAnalyzer).passes
require.Len(t, passes, 1)
changes := passes[0].File.Changes
require.Len(t, changes, 2)
require.Equal(t, "CREATE TABLE pets (id INT)", changes[0].Stmt.Text)
require.Equal(t, "DROP TABLE users", changes[1].Stmt.Text)
require.Equal(t, `2.sql: Report 1:
L1: Diagnostic 1
`, b.String())
b.Reset()
r.ReportWriter.(*lint.TemplateWriter).T = template.Must(template.New("").
Funcs(lint.TemplateFuncs).
Parse(`
Env:
{{ .Env.Driver }}, {{ .Env.Dir }}
Steps:
{{ range $s := .Steps }}
{{- if $s.Error }}
"Error in step " {{ $s.Name }} ": " {{ $s.Error }}
{{- else }}
{{- json $s }}
{{- end }}
{{ end }}
{{- if .Files }}
Files:
{{ range $f := .Files }}
{{- json $f }}
{{ end }}
{{- end }}
Current Schema:
{{ .Schema.Current }}
Desired Schema:
{{ .Schema.Desired }}
`))
require.NoError(t, r.Run(ctx))
require.Equal(t, `
Env:
sqlite3, migrations
Steps:
{"Name":"Detect New Migration Files","Text":"Found 1 new migration files (from 2 total)"}
{"Name":"Replay Migration Files","Text":"Loaded 1 changes on dev database"}
{"Name":"Analyze 2.sql","Text":"1 reports were found in analysis","Result":{"Name":"2.sql","Text":"CREATE TABLE pets (id INT)\nDROP TABLE users","Reports":[{"Text":"Report 2","Diagnostics":[{"Pos":1,"Text":"Diagnostic 1","Code":""},{"Pos":2,"Text":"Diagnostic 2","Code":""}]}]}}
Files:
{"Name":"2.sql","Text":"CREATE TABLE pets (id INT)\nDROP TABLE users","Reports":[{"Text":"Report 2","Diagnostics":[{"Pos":1,"Text":"Diagnostic 1","Code":""},{"Pos":2,"Text":"Diagnostic 2","Code":""}]}]}
Current Schema:
table "users" {
schema = schema.main
column "id" {
null = true
type = int
}
}
schema "main" {
}
Desired Schema:
table "pets" {
schema = schema.main
column "id" {
null = true
type = int
}
}
schema "main" {
}
`, b.String())
}
type testAnalyzer struct {
passes []*sqlcheck.Pass
}
func (t *testAnalyzer) Analyze(_ context.Context, p *sqlcheck.Pass) error {
t.passes = append(t.passes, p)
r := sqlcheck.Report{
Text: fmt.Sprintf("Report %d", len(t.passes)),
}
for i := 1; i <= len(t.passes); i++ {
r.Diagnostics = append(r.Diagnostics, sqlcheck.Diagnostic{
Pos: i,
Text: fmt.Sprintf("Diagnostic %d", i),
})
}
p.Reporter.WriteReport(r)
return nil
}
type testDetector struct {
base, feat []migrate.File
}
func (t testDetector) DetectChanges(context.Context) ([]migrate.File, []migrate.File, error) {
return t.base, t.feat, nil
}
atlas-0.7.2/cmd/atlas/internal/migrate/ 0000775 0000000 0000000 00000000000 14314555116 0017744 5 ustar 00root root 0000000 0000000 atlas-0.7.2/cmd/atlas/internal/migrate/ent/ 0000775 0000000 0000000 00000000000 14314555116 0020532 5 ustar 00root root 0000000 0000000 atlas-0.7.2/cmd/atlas/internal/migrate/ent/client.go 0000664 0000000 0000000 00000015003 14314555116 0022336 0 ustar 00root root 0000000 0000000 // Copyright 2021-present The Atlas Authors. All rights reserved.
// This source code is licensed under the Apache 2.0 license found
// in the LICENSE file in the root directory of this source tree.
// Code generated by entc, DO NOT EDIT.
package ent
import (
"context"
"fmt"
"log"
"ariga.io/atlas/cmd/atlas/internal/migrate/ent/migrate"
"ariga.io/atlas/cmd/atlas/internal/migrate/ent/revision"
"entgo.io/ent/dialect"
"entgo.io/ent/dialect/sql"
)
// Client is the client that holds all ent builders.
type Client struct {
config
// Schema is the client for creating, migrating and dropping schema.
Schema *migrate.Schema
// Revision is the client for interacting with the Revision builders.
Revision *RevisionClient
}
// NewClient creates a new client configured with the given options.
func NewClient(opts ...Option) *Client {
cfg := config{log: log.Println, hooks: &hooks{}}
cfg.options(opts...)
client := &Client{config: cfg}
client.init()
return client
}
func (c *Client) init() {
c.Schema = migrate.NewSchema(c.driver)
c.Revision = NewRevisionClient(c.config)
}
// Open opens a database/sql.DB specified by the driver name and
// the data source name, and returns a new client attached to it.
// Optional parameters can be added for configuring the client.
func Open(driverName, dataSourceName string, options ...Option) (*Client, error) {
switch driverName {
case dialect.MySQL, dialect.Postgres, dialect.SQLite:
drv, err := sql.Open(driverName, dataSourceName)
if err != nil {
return nil, err
}
return NewClient(append(options, Driver(drv))...), nil
default:
return nil, fmt.Errorf("unsupported driver: %q", driverName)
}
}
// Tx returns a new transactional client. The provided context
// is used until the transaction is committed or rolled back.
func (c *Client) Tx(ctx context.Context) (*Tx, error) {
if _, ok := c.driver.(*txDriver); ok {
return nil, fmt.Errorf("ent: cannot start a transaction within a transaction")
}
tx, err := newTx(ctx, c.driver)
if err != nil {
return nil, fmt.Errorf("ent: starting a transaction: %w", err)
}
cfg := c.config
cfg.driver = tx
return &Tx{
ctx: ctx,
config: cfg,
Revision: NewRevisionClient(cfg),
}, nil
}
// BeginTx returns a transactional client with specified options.
func (c *Client) BeginTx(ctx context.Context, opts *sql.TxOptions) (*Tx, error) {
if _, ok := c.driver.(*txDriver); ok {
return nil, fmt.Errorf("ent: cannot start a transaction within a transaction")
}
tx, err := c.driver.(interface {
BeginTx(context.Context, *sql.TxOptions) (dialect.Tx, error)
}).BeginTx(ctx, opts)
if err != nil {
return nil, fmt.Errorf("ent: starting a transaction: %w", err)
}
cfg := c.config
cfg.driver = &txDriver{tx: tx, drv: c.driver}
return &Tx{
ctx: ctx,
config: cfg,
Revision: NewRevisionClient(cfg),
}, nil
}
// Debug returns a new debug-client. It's used to get verbose logging on specific operations.
//
// client.Debug().
// Revision.
// Query().
// Count(ctx)
func (c *Client) Debug() *Client {
if c.debug {
return c
}
cfg := c.config
cfg.driver = dialect.Debug(c.driver, c.log)
client := &Client{config: cfg}
client.init()
return client
}
// Close closes the database connection and prevents new queries from starting.
func (c *Client) Close() error {
return c.driver.Close()
}
// Use adds the mutation hooks to all the entity clients.
// In order to add hooks to a specific client, call: `client.Node.Use(...)`.
func (c *Client) Use(hooks ...Hook) {
c.Revision.Use(hooks...)
}
// RevisionClient is a client for the Revision schema.
type RevisionClient struct {
config
}
// NewRevisionClient returns a client for the Revision from the given config.
func NewRevisionClient(c config) *RevisionClient {
return &RevisionClient{config: c}
}
// Use adds a list of mutation hooks to the hooks stack.
// A call to `Use(f, g, h)` equals to `revision.Hooks(f(g(h())))`.
func (c *RevisionClient) Use(hooks ...Hook) {
c.hooks.Revision = append(c.hooks.Revision, hooks...)
}
// Create returns a builder for creating a Revision entity.
func (c *RevisionClient) Create() *RevisionCreate {
mutation := newRevisionMutation(c.config, OpCreate)
return &RevisionCreate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// CreateBulk returns a builder for creating a bulk of Revision entities.
func (c *RevisionClient) CreateBulk(builders ...*RevisionCreate) *RevisionCreateBulk {
return &RevisionCreateBulk{config: c.config, builders: builders}
}
// Update returns an update builder for Revision.
func (c *RevisionClient) Update() *RevisionUpdate {
mutation := newRevisionMutation(c.config, OpUpdate)
return &RevisionUpdate{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// UpdateOne returns an update builder for the given entity.
func (c *RevisionClient) UpdateOne(r *Revision) *RevisionUpdateOne {
mutation := newRevisionMutation(c.config, OpUpdateOne, withRevision(r))
return &RevisionUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// UpdateOneID returns an update builder for the given id.
func (c *RevisionClient) UpdateOneID(id string) *RevisionUpdateOne {
mutation := newRevisionMutation(c.config, OpUpdateOne, withRevisionID(id))
return &RevisionUpdateOne{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// Delete returns a delete builder for Revision.
func (c *RevisionClient) Delete() *RevisionDelete {
mutation := newRevisionMutation(c.config, OpDelete)
return &RevisionDelete{config: c.config, hooks: c.Hooks(), mutation: mutation}
}
// DeleteOne returns a builder for deleting the given entity.
func (c *RevisionClient) DeleteOne(r *Revision) *RevisionDeleteOne {
return c.DeleteOneID(r.ID)
}
// DeleteOne returns a builder for deleting the given entity by its id.
func (c *RevisionClient) DeleteOneID(id string) *RevisionDeleteOne {
builder := c.Delete().Where(revision.ID(id))
builder.mutation.id = &id
builder.mutation.op = OpDeleteOne
return &RevisionDeleteOne{builder}
}
// Query returns a query builder for Revision.
func (c *RevisionClient) Query() *RevisionQuery {
return &RevisionQuery{
config: c.config,
}
}
// Get returns a Revision entity by its id.
func (c *RevisionClient) Get(ctx context.Context, id string) (*Revision, error) {
return c.Query().Where(revision.ID(id)).Only(ctx)
}
// GetX is like Get, but panics if an error occurs.
func (c *RevisionClient) GetX(ctx context.Context, id string) *Revision {
obj, err := c.Get(ctx, id)
if err != nil {
panic(err)
}
return obj
}
// Hooks returns the client hooks.
func (c *RevisionClient) Hooks() []Hook {
return c.hooks.Revision
}
atlas-0.7.2/cmd/atlas/internal/migrate/ent/config.go 0000664 0000000 0000000 00000005570 14314555116 0022335 0 ustar 00root root 0000000 0000000 // Copyright 2021-present The Atlas Authors. All rights reserved.
// This source code is licensed under the Apache 2.0 license found
// in the LICENSE file in the root directory of this source tree.
// Code generated by entc, DO NOT EDIT.
package ent
import (
"context"
stdsql "database/sql"
"fmt"
"ariga.io/atlas/cmd/atlas/internal/migrate/ent/internal"
"entgo.io/ent"
"entgo.io/ent/dialect"
)
// Option function to configure the client.
type Option func(*config)
// Config is the configuration for the client and its builder.
type config struct {
// driver used for executing database requests.
driver dialect.Driver
// debug enable a debug logging.
debug bool
// log used for logging on debug mode.
log func(...interface{})
// hooks to execute on mutations.
hooks *hooks
// schemaConfig contains alternative names for all tables.
schemaConfig SchemaConfig
}
// hooks per client, for fast access.
type hooks struct {
Revision []ent.Hook
}
// Options applies the options on the config object.
func (c *config) options(opts ...Option) {
for _, opt := range opts {
opt(c)
}
if c.debug {
c.driver = dialect.Debug(c.driver, c.log)
}
}
// Debug enables debug logging on the ent.Driver.
func Debug() Option {
return func(c *config) {
c.debug = true
}
}
// Log sets the logging function for debug mode.
func Log(fn func(...interface{})) Option {
return func(c *config) {
c.log = fn
}
}
// Driver configures the client driver.
func Driver(driver dialect.Driver) Option {
return func(c *config) {
c.driver = driver
}
}
// SchemaConfig represents alternative schema names for all tables
// that can be passed at runtime.
type SchemaConfig = internal.SchemaConfig
// AlternateSchemas allows alternate schema names to be
// passed into ent operations.
func AlternateSchema(schemaConfig SchemaConfig) Option {
return func(c *config) {
c.schemaConfig = schemaConfig
}
}
// ExecContext allows calling the underlying ExecContext method of the driver if it is supported by it.
// See, database/sql#DB.ExecContext for more information.
func (c *config) ExecContext(ctx context.Context, query string, args ...interface{}) (stdsql.Result, error) {
ex, ok := c.driver.(interface {
ExecContext(context.Context, string, ...interface{}) (stdsql.Result, error)
})
if !ok {
return nil, fmt.Errorf("Driver.ExecContext is not supported")
}
return ex.ExecContext(ctx, query, args...)
}
// QueryContext allows calling the underlying QueryContext method of the driver if it is supported by it.
// See, database/sql#DB.QueryContext for more information.
func (c *config) QueryContext(ctx context.Context, query string, args ...interface{}) (*stdsql.Rows, error) {
q, ok := c.driver.(interface {
QueryContext(context.Context, string, ...interface{}) (*stdsql.Rows, error)
})
if !ok {
return nil, fmt.Errorf("Driver.QueryContext is not supported")
}
return q.QueryContext(ctx, query, args...)
}
atlas-0.7.2/cmd/atlas/internal/migrate/ent/context.go 0000664 0000000 0000000 00000002066 14314555116 0022551 0 ustar 00root root 0000000 0000000 // Copyright 2021-present The Atlas Authors. All rights reserved.
// This source code is licensed under the Apache 2.0 license found
// in the LICENSE file in the root directory of this source tree.
// Code generated by entc, DO NOT EDIT.
package ent
import (
"context"
)
type clientCtxKey struct{}
// FromContext returns a Client stored inside a context, or nil if there isn't one.
func FromContext(ctx context.Context) *Client {
c, _ := ctx.Value(clientCtxKey{}).(*Client)
return c
}
// NewContext returns a new context with the given Client attached.
func NewContext(parent context.Context, c *Client) context.Context {
return context.WithValue(parent, clientCtxKey{}, c)
}
type txCtxKey struct{}
// TxFromContext returns a Tx stored inside a context, or nil if there isn't one.
func TxFromContext(ctx context.Context) *Tx {
tx, _ := ctx.Value(txCtxKey{}).(*Tx)
return tx
}
// NewTxContext returns a new context with the given Tx attached.
func NewTxContext(parent context.Context, tx *Tx) context.Context {
return context.WithValue(parent, txCtxKey{}, tx)
}
atlas-0.7.2/cmd/atlas/internal/migrate/ent/convert.go 0000664 0000000 0000000 00000002426 14314555116 0022545 0 ustar 00root root 0000000 0000000 // Copyright 2021-present The Atlas Authors. All rights reserved.
// This source code is licensed under the Apache 2.0 license found
// in the LICENSE file in the root directory of this source tree.
// Code generated by entc, DO NOT EDIT.
package ent
import "ariga.io/atlas/sql/migrate"
// SetRevision takes the values for each field from the given migrate.Revision.
func (rc *RevisionCreate) SetRevision(rev *migrate.Revision) *RevisionCreate {
rc.SetID(rev.Version)
rc.SetDescription(rev.Description)
rc.SetType(rev.Type)
rc.SetApplied(rev.Applied)
rc.SetTotal(rev.Total)
rc.SetExecutedAt(rev.ExecutedAt)
rc.SetExecutionTime(rev.ExecutionTime)
rc.SetError(rev.Error)
rc.SetHash(rev.Hash)
rc.SetPartialHashes(rev.PartialHashes)
rc.SetOperatorVersion(rev.OperatorVersion)
return rc
}
// AtlasRevision returns an migrate.Revision from the current Revision.
func (r *Revision) AtlasRevision() *migrate.Revision {
return &migrate.Revision{
Version: r.ID,
Description: r.Description,
Type: r.Type,
Applied: r.Applied,
Total: r.Total,
ExecutedAt: r.ExecutedAt,
ExecutionTime: r.ExecutionTime,
Error: r.Error,
Hash: r.Hash,
PartialHashes: r.PartialHashes,
OperatorVersion: r.OperatorVersion,
}
}
atlas-0.7.2/cmd/atlas/internal/migrate/ent/ent.go 0000664 0000000 0000000 00000027547 14314555116 0021666 0 ustar 00root root 0000000 0000000 // Copyright 2021-present The Atlas Authors. All rights reserved.
// This source code is licensed under the Apache 2.0 license found
// in the LICENSE file in the root directory of this source tree.
// Code generated by entc, DO NOT EDIT.
package ent
import (
"context"
"errors"
"fmt"
"ariga.io/atlas/cmd/atlas/internal/migrate/ent/revision"
"entgo.io/ent"
"entgo.io/ent/dialect/sql"
"entgo.io/ent/dialect/sql/sqlgraph"
)
// ent aliases to avoid import conflicts in user's code.
type (
Op = ent.Op
Hook = ent.Hook
Value = ent.Value
Query = ent.Query
Policy = ent.Policy
Mutator = ent.Mutator
Mutation = ent.Mutation
MutateFunc = ent.MutateFunc
)
// OrderFunc applies an ordering on the sql selector.
type OrderFunc func(*sql.Selector)
// columnChecker returns a function indicates if the column exists in the given column.
func columnChecker(table string) func(string) error {
checks := map[string]func(string) bool{
revision.Table: revision.ValidColumn,
}
check, ok := checks[table]
if !ok {
return func(string) error {
return fmt.Errorf("unknown table %q", table)
}
}
return func(column string) error {
if !check(column) {
return fmt.Errorf("unknown column %q for table %q", column, table)
}
return nil
}
}
// Asc applies the given fields in ASC order.
func Asc(fields ...string) OrderFunc {
return func(s *sql.Selector) {
check := columnChecker(s.TableName())
for _, f := range fields {
if err := check(f); err != nil {
s.AddError(&ValidationError{Name: f, err: fmt.Errorf("ent: %w", err)})
}
s.OrderBy(sql.Asc(s.C(f)))
}
}
}
// Desc applies the given fields in DESC order.
func Desc(fields ...string) OrderFunc {
return func(s *sql.Selector) {
check := columnChecker(s.TableName())
for _, f := range fields {
if err := check(f); err != nil {
s.AddError(&ValidationError{Name: f, err: fmt.Errorf("ent: %w", err)})
}
s.OrderBy(sql.Desc(s.C(f)))
}
}
}
// AggregateFunc applies an aggregation step on the group-by traversal/selector.
type AggregateFunc func(*sql.Selector) string
// As is a pseudo aggregation function for renaming another other functions with custom names. For example:
//
// GroupBy(field1, field2).
// Aggregate(ent.As(ent.Sum(field1), "sum_field1"), (ent.As(ent.Sum(field2), "sum_field2")).
// Scan(ctx, &v)
func As(fn AggregateFunc, end string) AggregateFunc {
return func(s *sql.Selector) string {
return sql.As(fn(s), end)
}
}
// Count applies the "count" aggregation function on each group.
func Count() AggregateFunc {
return func(s *sql.Selector) string {
return sql.Count("*")
}
}
// Max applies the "max" aggregation function on the given field of each group.
func Max(field string) AggregateFunc {
return func(s *sql.Selector) string {
check := columnChecker(s.TableName())
if err := check(field); err != nil {
s.AddError(&ValidationError{Name: field, err: fmt.Errorf("ent: %w", err)})
return ""
}
return sql.Max(s.C(field))
}
}
// Mean applies the "mean" aggregation function on the given field of each group.
func Mean(field string) AggregateFunc {
return func(s *sql.Selector) string {
check := columnChecker(s.TableName())
if err := check(field); err != nil {
s.AddError(&ValidationError{Name: field, err: fmt.Errorf("ent: %w", err)})
return ""
}
return sql.Avg(s.C(field))
}
}
// Min applies the "min" aggregation function on the given field of each group.
func Min(field string) AggregateFunc {
return func(s *sql.Selector) string {
check := columnChecker(s.TableName())
if err := check(field); err != nil {
s.AddError(&ValidationError{Name: field, err: fmt.Errorf("ent: %w", err)})
return ""
}
return sql.Min(s.C(field))
}
}
// Sum applies the "sum" aggregation function on the given field of each group.
func Sum(field string) AggregateFunc {
return func(s *sql.Selector) string {
check := columnChecker(s.TableName())
if err := check(field); err != nil {
s.AddError(&ValidationError{Name: field, err: fmt.Errorf("ent: %w", err)})
return ""
}
return sql.Sum(s.C(field))
}
}
// ValidationError returns when validating a field or edge fails.
type ValidationError struct {
Name string // Field or edge name.
err error
}
// Error implements the error interface.
func (e *ValidationError) Error() string {
return e.err.Error()
}
// Unwrap implements the errors.Wrapper interface.
func (e *ValidationError) Unwrap() error {
return e.err
}
// IsValidationError returns a boolean indicating whether the error is a validation error.
func IsValidationError(err error) bool {
if err == nil {
return false
}
var e *ValidationError
return errors.As(err, &e)
}
// NotFoundError returns when trying to fetch a specific entity and it was not found in the database.
type NotFoundError struct {
label string
}
// Error implements the error interface.
func (e *NotFoundError) Error() string {
return "ent: " + e.label + " not found"
}
// IsNotFound returns a boolean indicating whether the error is a not found error.
func IsNotFound(err error) bool {
if err == nil {
return false
}
var e *NotFoundError
return errors.As(err, &e)
}
// MaskNotFound masks not found error.
func MaskNotFound(err error) error {
if IsNotFound(err) {
return nil
}
return err
}
// NotSingularError returns when trying to fetch a singular entity and more then one was found in the database.
type NotSingularError struct {
label string
}
// Error implements the error interface.
func (e *NotSingularError) Error() string {
return "ent: " + e.label + " not singular"
}
// IsNotSingular returns a boolean indicating whether the error is a not singular error.
func IsNotSingular(err error) bool {
if err == nil {
return false
}
var e *NotSingularError
return errors.As(err, &e)
}
// NotLoadedError returns when trying to get a node that was not loaded by the query.
type NotLoadedError struct {
edge string
}
// Error implements the error interface.
func (e *NotLoadedError) Error() string {
return "ent: " + e.edge + " edge was not loaded"
}
// IsNotLoaded returns a boolean indicating whether the error is a not loaded error.
func IsNotLoaded(err error) bool {
if err == nil {
return false
}
var e *NotLoadedError
return errors.As(err, &e)
}
// ConstraintError returns when trying to create/update one or more entities and
// one or more of their constraints failed. For example, violation of edge or
// field uniqueness.
type ConstraintError struct {
msg string
wrap error
}
// Error implements the error interface.
func (e ConstraintError) Error() string {
return "ent: constraint failed: " + e.msg
}
// Unwrap implements the errors.Wrapper interface.
func (e *ConstraintError) Unwrap() error {
return e.wrap
}
// IsConstraintError returns a boolean indicating whether the error is a constraint failure.
func IsConstraintError(err error) bool {
if err == nil {
return false
}
var e *ConstraintError
return errors.As(err, &e)
}
// selector embedded by the different Select/GroupBy builders.
type selector struct {
label string
flds *[]string
scan func(context.Context, interface{}) error
}
// ScanX is like Scan, but panics if an error occurs.
func (s *selector) ScanX(ctx context.Context, v interface{}) {
if err := s.scan(ctx, v); err != nil {
panic(err)
}
}
// Strings returns list of strings from a selector. It is only allowed when selecting one field.
func (s *selector) Strings(ctx context.Context) ([]string, error) {
if len(*s.flds) > 1 {
return nil, errors.New("ent: Strings is not achievable when selecting more than 1 field")
}
var v []string
if err := s.scan(ctx, &v); err != nil {
return nil, err
}
return v, nil
}
// StringsX is like Strings, but panics if an error occurs.
func (s *selector) StringsX(ctx context.Context) []string {
v, err := s.Strings(ctx)
if err != nil {
panic(err)
}
return v
}
// String returns a single string from a selector. It is only allowed when selecting one field.
func (s *selector) String(ctx context.Context) (_ string, err error) {
var v []string
if v, err = s.Strings(ctx); err != nil {
return
}
switch len(v) {
case 1:
return v[0], nil
case 0:
err = &NotFoundError{s.label}
default:
err = fmt.Errorf("ent: Strings returned %d results when one was expected", len(v))
}
return
}
// StringX is like String, but panics if an error occurs.
func (s *selector) StringX(ctx context.Context) string {
v, err := s.String(ctx)
if err != nil {
panic(err)
}
return v
}
// Ints returns list of ints from a selector. It is only allowed when selecting one field.
func (s *selector) Ints(ctx context.Context) ([]int, error) {
if len(*s.flds) > 1 {
return nil, errors.New("ent: Ints is not achievable when selecting more than 1 field")
}
var v []int
if err := s.scan(ctx, &v); err != nil {
return nil, err
}
return v, nil
}
// IntsX is like Ints, but panics if an error occurs.
func (s *selector) IntsX(ctx context.Context) []int {
v, err := s.Ints(ctx)
if err != nil {
panic(err)
}
return v
}
// Int returns a single int from a selector. It is only allowed when selecting one field.
func (s *selector) Int(ctx context.Context) (_ int, err error) {
var v []int
if v, err = s.Ints(ctx); err != nil {
return
}
switch len(v) {
case 1:
return v[0], nil
case 0:
err = &NotFoundError{s.label}
default:
err = fmt.Errorf("ent: Ints returned %d results when one was expected", len(v))
}
return
}
// IntX is like Int, but panics if an error occurs.
func (s *selector) IntX(ctx context.Context) int {
v, err := s.Int(ctx)
if err != nil {
panic(err)
}
return v
}
// Float64s returns list of float64s from a selector. It is only allowed when selecting one field.
func (s *selector) Float64s(ctx context.Context) ([]float64, error) {
if len(*s.flds) > 1 {
return nil, errors.New("ent: Float64s is not achievable when selecting more than 1 field")
}
var v []float64
if err := s.scan(ctx, &v); err != nil {
return nil, err
}
return v, nil
}
// Float64sX is like Float64s, but panics if an error occurs.
func (s *selector) Float64sX(ctx context.Context) []float64 {
v, err := s.Float64s(ctx)
if err != nil {
panic(err)
}
return v
}
// Float64 returns a single float64 from a selector. It is only allowed when selecting one field.
func (s *selector) Float64(ctx context.Context) (_ float64, err error) {
var v []float64
if v, err = s.Float64s(ctx); err != nil {
return
}
switch len(v) {
case 1:
return v[0], nil
case 0:
err = &NotFoundError{s.label}
default:
err = fmt.Errorf("ent: Float64s returned %d results when one was expected", len(v))
}
return
}
// Float64X is like Float64, but panics if an error occurs.
func (s *selector) Float64X(ctx context.Context) float64 {
v, err := s.Float64(ctx)
if err != nil {
panic(err)
}
return v
}
// Bools returns list of bools from a selector. It is only allowed when selecting one field.
func (s *selector) Bools(ctx context.Context) ([]bool, error) {
if len(*s.flds) > 1 {
return nil, errors.New("ent: Bools is not achievable when selecting more than 1 field")
}
var v []bool
if err := s.scan(ctx, &v); err != nil {
return nil, err
}
return v, nil
}
// BoolsX is like Bools, but panics if an error occurs.
func (s *selector) BoolsX(ctx context.Context) []bool {
v, err := s.Bools(ctx)
if err != nil {
panic(err)
}
return v
}
// Bool returns a single bool from a selector. It is only allowed when selecting one field.
func (s *selector) Bool(ctx context.Context) (_ bool, err error) {
var v []bool
if v, err = s.Bools(ctx); err != nil {
return
}
switch len(v) {
case 1:
return v[0], nil
case 0:
err = &NotFoundError{s.label}
default:
err = fmt.Errorf("ent: Bools returned %d results when one was expected", len(v))
}
return
}
// BoolX is like Bool, but panics if an error occurs.
func (s *selector) BoolX(ctx context.Context) bool {
v, err := s.Bool(ctx)
if err != nil {
panic(err)
}
return v
}
// queryHook describes an internal hook for the different sqlAll methods.
type queryHook func(context.Context, *sqlgraph.QuerySpec)
atlas-0.7.2/cmd/atlas/internal/migrate/ent/entc.go 0000664 0000000 0000000 00000001466 14314555116 0022021 0 ustar 00root root 0000000 0000000 // Copyright 2021-present The Atlas Authors. All rights reserved.
// This source code is licensed under the Apache 2.0 license found
// in the LICENSE file in the root directory of this source tree.
//go:build ignore
package main
import (
"log"
"entgo.io/ent/entc"
"entgo.io/ent/entc/gen"
)
func main() {
err := entc.Generate("./schema", &gen.Config{
Header: `// Copyright 2021-present The Atlas Authors. All rights reserved.
// This source code is licensed under the Apache 2.0 license found
// in the LICENSE file in the root directory of this source tree.
// Code generated by entc, DO NOT EDIT.
`,
Features: []gen.Feature{
gen.FeatureUpsert,
gen.FeatureExecQuery,
gen.FeatureSchemaConfig,
},
}, entc.TemplateDir("template"))
if err != nil {
log.Fatalf("running ent codegen: %v", err)
}
}
atlas-0.7.2/cmd/atlas/internal/migrate/ent/enttest/ 0000775 0000000 0000000 00000000000 14314555116 0022220 5 ustar 00root root 0000000 0000000 atlas-0.7.2/cmd/atlas/internal/migrate/ent/enttest/enttest.go 0000664 0000000 0000000 00000004101 14314555116 0024231 0 ustar 00root root 0000000 0000000 // Copyright 2021-present The Atlas Authors. All rights reserved.
// This source code is licensed under the Apache 2.0 license found
// in the LICENSE file in the root directory of this source tree.
// Code generated by entc, DO NOT EDIT.
package enttest
import (
"context"
"ariga.io/atlas/cmd/atlas/internal/migrate/ent"
// required by schema hooks.
_ "ariga.io/atlas/cmd/atlas/internal/migrate/ent/runtime"
"ariga.io/atlas/cmd/atlas/internal/migrate/ent/migrate"
"entgo.io/ent/dialect/sql/schema"
)
type (
// TestingT is the interface that is shared between
// testing.T and testing.B and used by enttest.
TestingT interface {
FailNow()
Error(...interface{})
}
// Option configures client creation.
Option func(*options)
options struct {
opts []ent.Option
migrateOpts []schema.MigrateOption
}
)
// WithOptions forwards options to client creation.
func WithOptions(opts ...ent.Option) Option {
return func(o *options) {
o.opts = append(o.opts, opts...)
}
}
// WithMigrateOptions forwards options to auto migration.
func WithMigrateOptions(opts ...schema.MigrateOption) Option {
return func(o *options) {
o.migrateOpts = append(o.migrateOpts, opts...)
}
}
func newOptions(opts []Option) *options {
o := &options{}
for _, opt := range opts {
opt(o)
}
return o
}
// Open calls ent.Open and auto-run migration.
func Open(t TestingT, driverName, dataSourceName string, opts ...Option) *ent.Client {
o := newOptions(opts)
c, err := ent.Open(driverName, dataSourceName, o.opts...)
if err != nil {
t.Error(err)
t.FailNow()
}
migrateSchema(t, c, o)
return c
}
// NewClient calls ent.NewClient and auto-run migration.
func NewClient(t TestingT, opts ...Option) *ent.Client {
o := newOptions(opts)
c := ent.NewClient(o.opts...)
migrateSchema(t, c, o)
return c
}
func migrateSchema(t TestingT, c *ent.Client, o *options) {
tables, err := schema.CopyTables(migrate.Tables)
if err != nil {
t.Error(err)
t.FailNow()
}
if err := migrate.Create(context.Background(), c.Schema, tables, o.migrateOpts...); err != nil {
t.Error(err)
t.FailNow()
}
}
atlas-0.7.2/cmd/atlas/internal/migrate/ent/generate.go 0000664 0000000 0000000 00000000362 14314555116 0022654 0 ustar 00root root 0000000 0000000 // Copyright 2021-present The Atlas Authors. All rights reserved.
// This source code is licensed under the Apache 2.0 license found
// in the LICENSE file in the root directory of this source tree.
package ent
//go:generate go run entc.go
atlas-0.7.2/cmd/atlas/internal/migrate/ent/hook/ 0000775 0000000 0000000 00000000000 14314555116 0021472 5 ustar 00root root 0000000 0000000 atlas-0.7.2/cmd/atlas/internal/migrate/ent/hook/hook.go 0000664 0000000 0000000 00000012351 14314555116 0022763 0 ustar 00root root 0000000 0000000 // Copyright 2021-present The Atlas Authors. All rights reserved.
// This source code is licensed under the Apache 2.0 license found
// in the LICENSE file in the root directory of this source tree.
// Code generated by entc, DO NOT EDIT.
package hook
import (
"context"
"fmt"
"ariga.io/atlas/cmd/atlas/internal/migrate/ent"
)
// The RevisionFunc type is an adapter to allow the use of ordinary
// function as Revision mutator.
type RevisionFunc func(context.Context, *ent.RevisionMutation) (ent.Value, error)
// Mutate calls f(ctx, m).
func (f RevisionFunc) Mutate(ctx context.Context, m ent.Mutation) (ent.Value, error) {
mv, ok := m.(*ent.RevisionMutation)
if !ok {
return nil, fmt.Errorf("unexpected mutation type %T. expect *ent.RevisionMutation", m)
}
return f(ctx, mv)
}
// Condition is a hook condition function.
type Condition func(context.Context, ent.Mutation) bool
// And groups conditions with the AND operator.
func And(first, second Condition, rest ...Condition) Condition {
return func(ctx context.Context, m ent.Mutation) bool {
if !first(ctx, m) || !second(ctx, m) {
return false
}
for _, cond := range rest {
if !cond(ctx, m) {
return false
}
}
return true
}
}
// Or groups conditions with the OR operator.
func Or(first, second Condition, rest ...Condition) Condition {
return func(ctx context.Context, m ent.Mutation) bool {
if first(ctx, m) || second(ctx, m) {
return true
}
for _, cond := range rest {
if cond(ctx, m) {
return true
}
}
return false
}
}
// Not negates a given condition.
func Not(cond Condition) Condition {
return func(ctx context.Context, m ent.Mutation) bool {
return !cond(ctx, m)
}
}
// HasOp is a condition testing mutation operation.
func HasOp(op ent.Op) Condition {
return func(_ context.Context, m ent.Mutation) bool {
return m.Op().Is(op)
}
}
// HasAddedFields is a condition validating `.AddedField` on fields.
func HasAddedFields(field string, fields ...string) Condition {
return func(_ context.Context, m ent.Mutation) bool {
if _, exists := m.AddedField(field); !exists {
return false
}
for _, field := range fields {
if _, exists := m.AddedField(field); !exists {
return false
}
}
return true
}
}
// HasClearedFields is a condition validating `.FieldCleared` on fields.
func HasClearedFields(field string, fields ...string) Condition {
return func(_ context.Context, m ent.Mutation) bool {
if exists := m.FieldCleared(field); !exists {
return false
}
for _, field := range fields {
if exists := m.FieldCleared(field); !exists {
return false
}
}
return true
}
}
// HasFields is a condition validating `.Field` on fields.
func HasFields(field string, fields ...string) Condition {
return func(_ context.Context, m ent.Mutation) bool {
if _, exists := m.Field(field); !exists {
return false
}
for _, field := range fields {
if _, exists := m.Field(field); !exists {
return false
}
}
return true
}
}
// If executes the given hook under condition.
//
// hook.If(ComputeAverage, And(HasFields(...), HasAddedFields(...)))
func If(hk ent.Hook, cond Condition) ent.Hook {
return func(next ent.Mutator) ent.Mutator {
return ent.MutateFunc(func(ctx context.Context, m ent.Mutation) (ent.Value, error) {
if cond(ctx, m) {
return hk(next).Mutate(ctx, m)
}
return next.Mutate(ctx, m)
})
}
}
// On executes the given hook only for the given operation.
//
// hook.On(Log, ent.Delete|ent.Create)
func On(hk ent.Hook, op ent.Op) ent.Hook {
return If(hk, HasOp(op))
}
// Unless skips the given hook only for the given operation.
//
// hook.Unless(Log, ent.Update|ent.UpdateOne)
func Unless(hk ent.Hook, op ent.Op) ent.Hook {
return If(hk, Not(HasOp(op)))
}
// FixedError is a hook returning a fixed error.
func FixedError(err error) ent.Hook {
return func(ent.Mutator) ent.Mutator {
return ent.MutateFunc(func(context.Context, ent.Mutation) (ent.Value, error) {
return nil, err
})
}
}
// Reject returns a hook that rejects all operations that match op.
//
// func (T) Hooks() []ent.Hook {
// return []ent.Hook{
// Reject(ent.Delete|ent.Update),
// }
// }
func Reject(op ent.Op) ent.Hook {
hk := FixedError(fmt.Errorf("%s operation is not allowed", op))
return On(hk, op)
}
// Chain acts as a list of hooks and is effectively immutable.
// Once created, it will always hold the same set of hooks in the same order.
type Chain struct {
hooks []ent.Hook
}
// NewChain creates a new chain of hooks.
func NewChain(hooks ...ent.Hook) Chain {
return Chain{append([]ent.Hook(nil), hooks...)}
}
// Hook chains the list of hooks and returns the final hook.
func (c Chain) Hook() ent.Hook {
return func(mutator ent.Mutator) ent.Mutator {
for i := len(c.hooks) - 1; i >= 0; i-- {
mutator = c.hooks[i](mutator)
}
return mutator
}
}
// Append extends a chain, adding the specified hook
// as the last ones in the mutation flow.
func (c Chain) Append(hooks ...ent.Hook) Chain {
newHooks := make([]ent.Hook, 0, len(c.hooks)+len(hooks))
newHooks = append(newHooks, c.hooks...)
newHooks = append(newHooks, hooks...)
return Chain{newHooks}
}
// Extend extends a chain, adding the specified chain
// as the last ones in the mutation flow.
func (c Chain) Extend(chain Chain) Chain {
return c.Append(chain.hooks...)
}
atlas-0.7.2/cmd/atlas/internal/migrate/ent/internal/ 0000775 0000000 0000000 00000000000 14314555116 0022346 5 ustar 00root root 0000000 0000000 atlas-0.7.2/cmd/atlas/internal/migrate/ent/internal/schemaconfig.go 0000664 0000000 0000000 00000001667 14314555116 0025335 0 ustar 00root root 0000000 0000000 // Copyright 2021-present The Atlas Authors. All rights reserved.
// This source code is licensed under the Apache 2.0 license found
// in the LICENSE file in the root directory of this source tree.
// Code generated by entc, DO NOT EDIT.
package internal
import "context"
// SchemaConfig represents alternative schema names for all tables
// that can be passed at runtime.
type SchemaConfig struct {
Revision string // Revision table.
}
type schemaCtxKey struct{}
// SchemaConfigFromContext returns a SchemaConfig stored inside a context, or empty if there isn't one.
func SchemaConfigFromContext(ctx context.Context) SchemaConfig {
config, _ := ctx.Value(schemaCtxKey{}).(SchemaConfig)
return config
}
// NewSchemaConfigContext returns a new context with the given SchemaConfig attached.
func NewSchemaConfigContext(parent context.Context, config SchemaConfig) context.Context {
return context.WithValue(parent, schemaCtxKey{}, config)
}
atlas-0.7.2/cmd/atlas/internal/migrate/ent/migrate/ 0000775 0000000 0000000 00000000000 14314555116 0022162 5 ustar 00root root 0000000 0000000 atlas-0.7.2/cmd/atlas/internal/migrate/ent/migrate/migrate.go 0000664 0000000 0000000 00000005005 14314555116 0024141 0 ustar 00root root 0000000 0000000 // Copyright 2021-present The Atlas Authors. All rights reserved.
// This source code is licensed under the Apache 2.0 license found
// in the LICENSE file in the root directory of this source tree.
// Code generated by entc, DO NOT EDIT.
package migrate
import (
"context"
"fmt"
"io"
"entgo.io/ent/dialect"
"entgo.io/ent/dialect/sql/schema"
)
var (
// WithGlobalUniqueID sets the universal ids options to the migration.
// If this option is enabled, ent migration will allocate a 1<<32 range
// for the ids of each entity (table).
// Note that this option cannot be applied on tables that already exist.
WithGlobalUniqueID = schema.WithGlobalUniqueID
// WithDropColumn sets the drop column option to the migration.
// If this option is enabled, ent migration will drop old columns
// that were used for both fields and edges. This defaults to false.
WithDropColumn = schema.WithDropColumn
// WithDropIndex sets the drop index option to the migration.
// If this option is enabled, ent migration will drop old indexes
// that were defined in the schema. This defaults to false.
// Note that unique constraints are defined using `UNIQUE INDEX`,
// and therefore, it's recommended to enable this option to get more
// flexibility in the schema changes.
WithDropIndex = schema.WithDropIndex
// WithForeignKeys enables creating foreign-key in schema DDL. This defaults to true.
WithForeignKeys = schema.WithForeignKeys
)
// Schema is the API for creating, migrating and dropping a schema.
type Schema struct {
drv dialect.Driver
}
// NewSchema creates a new schema client.
func NewSchema(drv dialect.Driver) *Schema { return &Schema{drv: drv} }
// Create creates all schema resources.
func (s *Schema) Create(ctx context.Context, opts ...schema.MigrateOption) error {
return Create(ctx, s, Tables, opts...)
}
// Create creates all table resources using the given schema driver.
func Create(ctx context.Context, s *Schema, tables []*schema.Table, opts ...schema.MigrateOption) error {
migrate, err := schema.NewMigrate(s.drv, opts...)
if err != nil {
return fmt.Errorf("ent/migrate: %w", err)
}
return migrate.Create(ctx, tables...)
}
// WriteTo writes the schema changes to w instead of running them against the database.
//
// if err := client.Schema.WriteTo(context.Background(), os.Stdout); err != nil {
// log.Fatal(err)
// }
func (s *Schema) WriteTo(ctx context.Context, w io.Writer, opts ...schema.MigrateOption) error {
return Create(ctx, &Schema{drv: &schema.WriteDriver{Writer: w, Driver: s.drv}}, Tables, opts...)
}
atlas-0.7.2/cmd/atlas/internal/migrate/ent/migrate/schema.go 0000664 0000000 0000000 00000003122 14314555116 0023747 0 ustar 00root root 0000000 0000000 // Copyright 2021-present The Atlas Authors. All rights reserved.
// This source code is licensed under the Apache 2.0 license found
// in the LICENSE file in the root directory of this source tree.
// Code generated by entc, DO NOT EDIT.
package migrate
import (
"entgo.io/ent/dialect/entsql"
"entgo.io/ent/dialect/sql/schema"
"entgo.io/ent/schema/field"
)
var (
// AtlasSchemaRevisionsColumns holds the columns for the "atlas_schema_revisions" table.
AtlasSchemaRevisionsColumns = []*schema.Column{
{Name: "version", Type: field.TypeString},
{Name: "description", Type: field.TypeString},
{Name: "type", Type: field.TypeUint, Default: 2},
{Name: "applied", Type: field.TypeInt, Default: 0},
{Name: "total", Type: field.TypeInt, Default: 0},
{Name: "executed_at", Type: field.TypeTime},
{Name: "execution_time", Type: field.TypeInt64},
{Name: "error", Type: field.TypeString, Nullable: true, Size: 2147483647},
{Name: "hash", Type: field.TypeString},
{Name: "partial_hashes", Type: field.TypeJSON, Nullable: true},
{Name: "operator_version", Type: field.TypeString},
}
// AtlasSchemaRevisionsTable holds the schema information for the "atlas_schema_revisions" table.
AtlasSchemaRevisionsTable = &schema.Table{
Name: "atlas_schema_revisions",
Columns: AtlasSchemaRevisionsColumns,
PrimaryKey: []*schema.Column{AtlasSchemaRevisionsColumns[0]},
}
// Tables holds all the tables in the schema.
Tables = []*schema.Table{
AtlasSchemaRevisionsTable,
}
)
func init() {
AtlasSchemaRevisionsTable.Annotation = &entsql.Annotation{
Table: "atlas_schema_revisions",
}
}
atlas-0.7.2/cmd/atlas/internal/migrate/ent/mutation.go 0000664 0000000 0000000 00000072730 14314555116 0022732 0 ustar 00root root 0000000 0000000 // Copyright 2021-present The Atlas Authors. All rights reserved.
// This source code is licensed under the Apache 2.0 license found
// in the LICENSE file in the root directory of this source tree.
// Code generated by entc, DO NOT EDIT.
package ent
import (
"context"
"errors"
"fmt"
"sync"
"time"
"ariga.io/atlas/cmd/atlas/internal/migrate/ent/predicate"
"ariga.io/atlas/cmd/atlas/internal/migrate/ent/revision"
"ariga.io/atlas/sql/migrate"
"entgo.io/ent"
)
const (
// Operation types.
OpCreate = ent.OpCreate
OpDelete = ent.OpDelete
OpDeleteOne = ent.OpDeleteOne
OpUpdate = ent.OpUpdate
OpUpdateOne = ent.OpUpdateOne
// Node types.
TypeRevision = "Revision"
)
// RevisionMutation represents an operation that mutates the Revision nodes in the graph.
type RevisionMutation struct {
config
op Op
typ string
id *string
description *string
_type *migrate.RevisionType
add_type *migrate.RevisionType
applied *int
addapplied *int
total *int
addtotal *int
executed_at *time.Time
execution_time *time.Duration
addexecution_time *time.Duration
error *string
hash *string
partial_hashes *[]string
operator_version *string
clearedFields map[string]struct{}
done bool
oldValue func(context.Context) (*Revision, error)
predicates []predicate.Revision
}
var _ ent.Mutation = (*RevisionMutation)(nil)
// revisionOption allows management of the mutation configuration using functional options.
type revisionOption func(*RevisionMutation)
// newRevisionMutation creates new mutation for the Revision entity.
func newRevisionMutation(c config, op Op, opts ...revisionOption) *RevisionMutation {
m := &RevisionMutation{
config: c,
op: op,
typ: TypeRevision,
clearedFields: make(map[string]struct{}),
}
for _, opt := range opts {
opt(m)
}
return m
}
// withRevisionID sets the ID field of the mutation.
func withRevisionID(id string) revisionOption {
return func(m *RevisionMutation) {
var (
err error
once sync.Once
value *Revision
)
m.oldValue = func(ctx context.Context) (*Revision, error) {
once.Do(func() {
if m.done {
err = errors.New("querying old values post mutation is not allowed")
} else {
value, err = m.Client().Revision.Get(ctx, id)
}
})
return value, err
}
m.id = &id
}
}
// withRevision sets the old Revision of the mutation.
func withRevision(node *Revision) revisionOption {
return func(m *RevisionMutation) {
m.oldValue = func(context.Context) (*Revision, error) {
return node, nil
}
m.id = &node.ID
}
}
// Client returns a new `ent.Client` from the mutation. If the mutation was
// executed in a transaction (ent.Tx), a transactional client is returned.
func (m RevisionMutation) Client() *Client {
client := &Client{config: m.config}
client.init()
return client
}
// Tx returns an `ent.Tx` for mutations that were executed in transactions;
// it returns an error otherwise.
func (m RevisionMutation) Tx() (*Tx, error) {
if _, ok := m.driver.(*txDriver); !ok {
return nil, errors.New("ent: mutation is not running in a transaction")
}
tx := &Tx{config: m.config}
tx.init()
return tx, nil
}
// SetID sets the value of the id field. Note that this
// operation is only accepted on creation of Revision entities.
func (m *RevisionMutation) SetID(id string) {
m.id = &id
}
// ID returns the ID value in the mutation. Note that the ID is only available
// if it was provided to the builder or after it was returned from the database.
func (m *RevisionMutation) ID() (id string, exists bool) {
if m.id == nil {
return
}
return *m.id, true
}
// IDs queries the database and returns the entity ids that match the mutation's predicate.
// That means, if the mutation is applied within a transaction with an isolation level such
// as sql.LevelSerializable, the returned ids match the ids of the rows that will be updated
// or updated by the mutation.
func (m *RevisionMutation) IDs(ctx context.Context) ([]string, error) {
switch {
case m.op.Is(OpUpdateOne | OpDeleteOne):
id, exists := m.ID()
if exists {
return []string{id}, nil
}
fallthrough
case m.op.Is(OpUpdate | OpDelete):
return m.Client().Revision.Query().Where(m.predicates...).IDs(ctx)
default:
return nil, fmt.Errorf("IDs is not allowed on %s operations", m.op)
}
}
// SetDescription sets the "description" field.
func (m *RevisionMutation) SetDescription(s string) {
m.description = &s
}
// Description returns the value of the "description" field in the mutation.
func (m *RevisionMutation) Description() (r string, exists bool) {
v := m.description
if v == nil {
return
}
return *v, true
}
// OldDescription returns the old "description" field's value of the Revision entity.
// If the Revision object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *RevisionMutation) OldDescription(ctx context.Context) (v string, err error) {
if !m.op.Is(OpUpdateOne) {
return v, errors.New("OldDescription is only allowed on UpdateOne operations")
}
if m.id == nil || m.oldValue == nil {
return v, errors.New("OldDescription requires an ID field in the mutation")
}
oldValue, err := m.oldValue(ctx)
if err != nil {
return v, fmt.Errorf("querying old value for OldDescription: %w", err)
}
return oldValue.Description, nil
}
// ResetDescription resets all changes to the "description" field.
func (m *RevisionMutation) ResetDescription() {
m.description = nil
}
// SetType sets the "type" field.
func (m *RevisionMutation) SetType(mt migrate.RevisionType) {
m._type = &mt
m.add_type = nil
}
// GetType returns the value of the "type" field in the mutation.
func (m *RevisionMutation) GetType() (r migrate.RevisionType, exists bool) {
v := m._type
if v == nil {
return
}
return *v, true
}
// OldType returns the old "type" field's value of the Revision entity.
// If the Revision object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *RevisionMutation) OldType(ctx context.Context) (v migrate.RevisionType, err error) {
if !m.op.Is(OpUpdateOne) {
return v, errors.New("OldType is only allowed on UpdateOne operations")
}
if m.id == nil || m.oldValue == nil {
return v, errors.New("OldType requires an ID field in the mutation")
}
oldValue, err := m.oldValue(ctx)
if err != nil {
return v, fmt.Errorf("querying old value for OldType: %w", err)
}
return oldValue.Type, nil
}
// AddType adds mt to the "type" field.
func (m *RevisionMutation) AddType(mt migrate.RevisionType) {
if m.add_type != nil {
*m.add_type += mt
} else {
m.add_type = &mt
}
}
// AddedType returns the value that was added to the "type" field in this mutation.
func (m *RevisionMutation) AddedType() (r migrate.RevisionType, exists bool) {
v := m.add_type
if v == nil {
return
}
return *v, true
}
// ResetType resets all changes to the "type" field.
func (m *RevisionMutation) ResetType() {
m._type = nil
m.add_type = nil
}
// SetApplied sets the "applied" field.
func (m *RevisionMutation) SetApplied(i int) {
m.applied = &i
m.addapplied = nil
}
// Applied returns the value of the "applied" field in the mutation.
func (m *RevisionMutation) Applied() (r int, exists bool) {
v := m.applied
if v == nil {
return
}
return *v, true
}
// OldApplied returns the old "applied" field's value of the Revision entity.
// If the Revision object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *RevisionMutation) OldApplied(ctx context.Context) (v int, err error) {
if !m.op.Is(OpUpdateOne) {
return v, errors.New("OldApplied is only allowed on UpdateOne operations")
}
if m.id == nil || m.oldValue == nil {
return v, errors.New("OldApplied requires an ID field in the mutation")
}
oldValue, err := m.oldValue(ctx)
if err != nil {
return v, fmt.Errorf("querying old value for OldApplied: %w", err)
}
return oldValue.Applied, nil
}
// AddApplied adds i to the "applied" field.
func (m *RevisionMutation) AddApplied(i int) {
if m.addapplied != nil {
*m.addapplied += i
} else {
m.addapplied = &i
}
}
// AddedApplied returns the value that was added to the "applied" field in this mutation.
func (m *RevisionMutation) AddedApplied() (r int, exists bool) {
v := m.addapplied
if v == nil {
return
}
return *v, true
}
// ResetApplied resets all changes to the "applied" field.
func (m *RevisionMutation) ResetApplied() {
m.applied = nil
m.addapplied = nil
}
// SetTotal sets the "total" field.
func (m *RevisionMutation) SetTotal(i int) {
m.total = &i
m.addtotal = nil
}
// Total returns the value of the "total" field in the mutation.
func (m *RevisionMutation) Total() (r int, exists bool) {
v := m.total
if v == nil {
return
}
return *v, true
}
// OldTotal returns the old "total" field's value of the Revision entity.
// If the Revision object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *RevisionMutation) OldTotal(ctx context.Context) (v int, err error) {
if !m.op.Is(OpUpdateOne) {
return v, errors.New("OldTotal is only allowed on UpdateOne operations")
}
if m.id == nil || m.oldValue == nil {
return v, errors.New("OldTotal requires an ID field in the mutation")
}
oldValue, err := m.oldValue(ctx)
if err != nil {
return v, fmt.Errorf("querying old value for OldTotal: %w", err)
}
return oldValue.Total, nil
}
// AddTotal adds i to the "total" field.
func (m *RevisionMutation) AddTotal(i int) {
if m.addtotal != nil {
*m.addtotal += i
} else {
m.addtotal = &i
}
}
// AddedTotal returns the value that was added to the "total" field in this mutation.
func (m *RevisionMutation) AddedTotal() (r int, exists bool) {
v := m.addtotal
if v == nil {
return
}
return *v, true
}
// ResetTotal resets all changes to the "total" field.
func (m *RevisionMutation) ResetTotal() {
m.total = nil
m.addtotal = nil
}
// SetExecutedAt sets the "executed_at" field.
func (m *RevisionMutation) SetExecutedAt(t time.Time) {
m.executed_at = &t
}
// ExecutedAt returns the value of the "executed_at" field in the mutation.
func (m *RevisionMutation) ExecutedAt() (r time.Time, exists bool) {
v := m.executed_at
if v == nil {
return
}
return *v, true
}
// OldExecutedAt returns the old "executed_at" field's value of the Revision entity.
// If the Revision object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *RevisionMutation) OldExecutedAt(ctx context.Context) (v time.Time, err error) {
if !m.op.Is(OpUpdateOne) {
return v, errors.New("OldExecutedAt is only allowed on UpdateOne operations")
}
if m.id == nil || m.oldValue == nil {
return v, errors.New("OldExecutedAt requires an ID field in the mutation")
}
oldValue, err := m.oldValue(ctx)
if err != nil {
return v, fmt.Errorf("querying old value for OldExecutedAt: %w", err)
}
return oldValue.ExecutedAt, nil
}
// ResetExecutedAt resets all changes to the "executed_at" field.
func (m *RevisionMutation) ResetExecutedAt() {
m.executed_at = nil
}
// SetExecutionTime sets the "execution_time" field.
func (m *RevisionMutation) SetExecutionTime(t time.Duration) {
m.execution_time = &t
m.addexecution_time = nil
}
// ExecutionTime returns the value of the "execution_time" field in the mutation.
func (m *RevisionMutation) ExecutionTime() (r time.Duration, exists bool) {
v := m.execution_time
if v == nil {
return
}
return *v, true
}
// OldExecutionTime returns the old "execution_time" field's value of the Revision entity.
// If the Revision object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *RevisionMutation) OldExecutionTime(ctx context.Context) (v time.Duration, err error) {
if !m.op.Is(OpUpdateOne) {
return v, errors.New("OldExecutionTime is only allowed on UpdateOne operations")
}
if m.id == nil || m.oldValue == nil {
return v, errors.New("OldExecutionTime requires an ID field in the mutation")
}
oldValue, err := m.oldValue(ctx)
if err != nil {
return v, fmt.Errorf("querying old value for OldExecutionTime: %w", err)
}
return oldValue.ExecutionTime, nil
}
// AddExecutionTime adds t to the "execution_time" field.
func (m *RevisionMutation) AddExecutionTime(t time.Duration) {
if m.addexecution_time != nil {
*m.addexecution_time += t
} else {
m.addexecution_time = &t
}
}
// AddedExecutionTime returns the value that was added to the "execution_time" field in this mutation.
func (m *RevisionMutation) AddedExecutionTime() (r time.Duration, exists bool) {
v := m.addexecution_time
if v == nil {
return
}
return *v, true
}
// ResetExecutionTime resets all changes to the "execution_time" field.
func (m *RevisionMutation) ResetExecutionTime() {
m.execution_time = nil
m.addexecution_time = nil
}
// SetError sets the "error" field.
func (m *RevisionMutation) SetError(s string) {
m.error = &s
}
// Error returns the value of the "error" field in the mutation.
func (m *RevisionMutation) Error() (r string, exists bool) {
v := m.error
if v == nil {
return
}
return *v, true
}
// OldError returns the old "error" field's value of the Revision entity.
// If the Revision object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *RevisionMutation) OldError(ctx context.Context) (v string, err error) {
if !m.op.Is(OpUpdateOne) {
return v, errors.New("OldError is only allowed on UpdateOne operations")
}
if m.id == nil || m.oldValue == nil {
return v, errors.New("OldError requires an ID field in the mutation")
}
oldValue, err := m.oldValue(ctx)
if err != nil {
return v, fmt.Errorf("querying old value for OldError: %w", err)
}
return oldValue.Error, nil
}
// ClearError clears the value of the "error" field.
func (m *RevisionMutation) ClearError() {
m.error = nil
m.clearedFields[revision.FieldError] = struct{}{}
}
// ErrorCleared returns if the "error" field was cleared in this mutation.
func (m *RevisionMutation) ErrorCleared() bool {
_, ok := m.clearedFields[revision.FieldError]
return ok
}
// ResetError resets all changes to the "error" field.
func (m *RevisionMutation) ResetError() {
m.error = nil
delete(m.clearedFields, revision.FieldError)
}
// SetHash sets the "hash" field.
func (m *RevisionMutation) SetHash(s string) {
m.hash = &s
}
// Hash returns the value of the "hash" field in the mutation.
func (m *RevisionMutation) Hash() (r string, exists bool) {
v := m.hash
if v == nil {
return
}
return *v, true
}
// OldHash returns the old "hash" field's value of the Revision entity.
// If the Revision object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *RevisionMutation) OldHash(ctx context.Context) (v string, err error) {
if !m.op.Is(OpUpdateOne) {
return v, errors.New("OldHash is only allowed on UpdateOne operations")
}
if m.id == nil || m.oldValue == nil {
return v, errors.New("OldHash requires an ID field in the mutation")
}
oldValue, err := m.oldValue(ctx)
if err != nil {
return v, fmt.Errorf("querying old value for OldHash: %w", err)
}
return oldValue.Hash, nil
}
// ResetHash resets all changes to the "hash" field.
func (m *RevisionMutation) ResetHash() {
m.hash = nil
}
// SetPartialHashes sets the "partial_hashes" field.
func (m *RevisionMutation) SetPartialHashes(s []string) {
m.partial_hashes = &s
}
// PartialHashes returns the value of the "partial_hashes" field in the mutation.
func (m *RevisionMutation) PartialHashes() (r []string, exists bool) {
v := m.partial_hashes
if v == nil {
return
}
return *v, true
}
// OldPartialHashes returns the old "partial_hashes" field's value of the Revision entity.
// If the Revision object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *RevisionMutation) OldPartialHashes(ctx context.Context) (v []string, err error) {
if !m.op.Is(OpUpdateOne) {
return v, errors.New("OldPartialHashes is only allowed on UpdateOne operations")
}
if m.id == nil || m.oldValue == nil {
return v, errors.New("OldPartialHashes requires an ID field in the mutation")
}
oldValue, err := m.oldValue(ctx)
if err != nil {
return v, fmt.Errorf("querying old value for OldPartialHashes: %w", err)
}
return oldValue.PartialHashes, nil
}
// ClearPartialHashes clears the value of the "partial_hashes" field.
func (m *RevisionMutation) ClearPartialHashes() {
m.partial_hashes = nil
m.clearedFields[revision.FieldPartialHashes] = struct{}{}
}
// PartialHashesCleared returns if the "partial_hashes" field was cleared in this mutation.
func (m *RevisionMutation) PartialHashesCleared() bool {
_, ok := m.clearedFields[revision.FieldPartialHashes]
return ok
}
// ResetPartialHashes resets all changes to the "partial_hashes" field.
func (m *RevisionMutation) ResetPartialHashes() {
m.partial_hashes = nil
delete(m.clearedFields, revision.FieldPartialHashes)
}
// SetOperatorVersion sets the "operator_version" field.
func (m *RevisionMutation) SetOperatorVersion(s string) {
m.operator_version = &s
}
// OperatorVersion returns the value of the "operator_version" field in the mutation.
func (m *RevisionMutation) OperatorVersion() (r string, exists bool) {
v := m.operator_version
if v == nil {
return
}
return *v, true
}
// OldOperatorVersion returns the old "operator_version" field's value of the Revision entity.
// If the Revision object wasn't provided to the builder, the object is fetched from the database.
// An error is returned if the mutation operation is not UpdateOne, or the database query fails.
func (m *RevisionMutation) OldOperatorVersion(ctx context.Context) (v string, err error) {
if !m.op.Is(OpUpdateOne) {
return v, errors.New("OldOperatorVersion is only allowed on UpdateOne operations")
}
if m.id == nil || m.oldValue == nil {
return v, errors.New("OldOperatorVersion requires an ID field in the mutation")
}
oldValue, err := m.oldValue(ctx)
if err != nil {
return v, fmt.Errorf("querying old value for OldOperatorVersion: %w", err)
}
return oldValue.OperatorVersion, nil
}
// ResetOperatorVersion resets all changes to the "operator_version" field.
func (m *RevisionMutation) ResetOperatorVersion() {
m.operator_version = nil
}
// Where appends a list predicates to the RevisionMutation builder.
func (m *RevisionMutation) Where(ps ...predicate.Revision) {
m.predicates = append(m.predicates, ps...)
}
// Op returns the operation name.
func (m *RevisionMutation) Op() Op {
return m.op
}
// Type returns the node type of this mutation (Revision).
func (m *RevisionMutation) Type() string {
return m.typ
}
// Fields returns all fields that were changed during this mutation. Note that in
// order to get all numeric fields that were incremented/decremented, call
// AddedFields().
func (m *RevisionMutation) Fields() []string {
fields := make([]string, 0, 10)
if m.description != nil {
fields = append(fields, revision.FieldDescription)
}
if m._type != nil {
fields = append(fields, revision.FieldType)
}
if m.applied != nil {
fields = append(fields, revision.FieldApplied)
}
if m.total != nil {
fields = append(fields, revision.FieldTotal)
}
if m.executed_at != nil {
fields = append(fields, revision.FieldExecutedAt)
}
if m.execution_time != nil {
fields = append(fields, revision.FieldExecutionTime)
}
if m.error != nil {
fields = append(fields, revision.FieldError)
}
if m.hash != nil {
fields = append(fields, revision.FieldHash)
}
if m.partial_hashes != nil {
fields = append(fields, revision.FieldPartialHashes)
}
if m.operator_version != nil {
fields = append(fields, revision.FieldOperatorVersion)
}
return fields
}
// Field returns the value of a field with the given name. The second boolean
// return value indicates that this field was not set, or was not defined in the
// schema.
func (m *RevisionMutation) Field(name string) (ent.Value, bool) {
switch name {
case revision.FieldDescription:
return m.Description()
case revision.FieldType:
return m.GetType()
case revision.FieldApplied:
return m.Applied()
case revision.FieldTotal:
return m.Total()
case revision.FieldExecutedAt:
return m.ExecutedAt()
case revision.FieldExecutionTime:
return m.ExecutionTime()
case revision.FieldError:
return m.Error()
case revision.FieldHash:
return m.Hash()
case revision.FieldPartialHashes:
return m.PartialHashes()
case revision.FieldOperatorVersion:
return m.OperatorVersion()
}
return nil, false
}
// OldField returns the old value of the field from the database. An error is
// returned if the mutation operation is not UpdateOne, or the query to the
// database failed.
func (m *RevisionMutation) OldField(ctx context.Context, name string) (ent.Value, error) {
switch name {
case revision.FieldDescription:
return m.OldDescription(ctx)
case revision.FieldType:
return m.OldType(ctx)
case revision.FieldApplied:
return m.OldApplied(ctx)
case revision.FieldTotal:
return m.OldTotal(ctx)
case revision.FieldExecutedAt:
return m.OldExecutedAt(ctx)
case revision.FieldExecutionTime:
return m.OldExecutionTime(ctx)
case revision.FieldError:
return m.OldError(ctx)
case revision.FieldHash:
return m.OldHash(ctx)
case revision.FieldPartialHashes:
return m.OldPartialHashes(ctx)
case revision.FieldOperatorVersion:
return m.OldOperatorVersion(ctx)
}
return nil, fmt.Errorf("unknown Revision field %s", name)
}
// SetField sets the value of a field with the given name. It returns an error if
// the field is not defined in the schema, or if the type mismatched the field
// type.
func (m *RevisionMutation) SetField(name string, value ent.Value) error {
switch name {
case revision.FieldDescription:
v, ok := value.(string)
if !ok {
return fmt.Errorf("unexpected type %T for field %s", value, name)
}
m.SetDescription(v)
return nil
case revision.FieldType:
v, ok := value.(migrate.RevisionType)
if !ok {
return fmt.Errorf("unexpected type %T for field %s", value, name)
}
m.SetType(v)
return nil
case revision.FieldApplied:
v, ok := value.(int)
if !ok {
return fmt.Errorf("unexpected type %T for field %s", value, name)
}
m.SetApplied(v)
return nil
case revision.FieldTotal:
v, ok := value.(int)
if !ok {
return fmt.Errorf("unexpected type %T for field %s", value, name)
}
m.SetTotal(v)
return nil
case revision.FieldExecutedAt:
v, ok := value.(time.Time)
if !ok {
return fmt.Errorf("unexpected type %T for field %s", value, name)
}
m.SetExecutedAt(v)
return nil
case revision.FieldExecutionTime:
v, ok := value.(time.Duration)
if !ok {
return fmt.Errorf("unexpected type %T for field %s", value, name)
}
m.SetExecutionTime(v)
return nil
case revision.FieldError:
v, ok := value.(string)
if !ok {
return fmt.Errorf("unexpected type %T for field %s", value, name)
}
m.SetError(v)
return nil
case revision.FieldHash:
v, ok := value.(string)
if !ok {
return fmt.Errorf("unexpected type %T for field %s", value, name)
}
m.SetHash(v)
return nil
case revision.FieldPartialHashes:
v, ok := value.([]string)
if !ok {
return fmt.Errorf("unexpected type %T for field %s", value, name)
}
m.SetPartialHashes(v)
return nil
case revision.FieldOperatorVersion:
v, ok := value.(string)
if !ok {
return fmt.Errorf("unexpected type %T for field %s", value, name)
}
m.SetOperatorVersion(v)
return nil
}
return fmt.Errorf("unknown Revision field %s", name)
}
// AddedFields returns all numeric fields that were incremented/decremented during
// this mutation.
func (m *RevisionMutation) AddedFields() []string {
var fields []string
if m.add_type != nil {
fields = append(fields, revision.FieldType)
}
if m.addapplied != nil {
fields = append(fields, revision.FieldApplied)
}
if m.addtotal != nil {
fields = append(fields, revision.FieldTotal)
}
if m.addexecution_time != nil {
fields = append(fields, revision.FieldExecutionTime)
}
return fields
}
// AddedField returns the numeric value that was incremented/decremented on a field
// with the given name. The second boolean return value indicates that this field
// was not set, or was not defined in the schema.
func (m *RevisionMutation) AddedField(name string) (ent.Value, bool) {
switch name {
case revision.FieldType:
return m.AddedType()
case revision.FieldApplied:
return m.AddedApplied()
case revision.FieldTotal:
return m.AddedTotal()
case revision.FieldExecutionTime:
return m.AddedExecutionTime()
}
return nil, false
}
// AddField adds the value to the field with the given name. It returns an error if
// the field is not defined in the schema, or if the type mismatched the field
// type.
func (m *RevisionMutation) AddField(name string, value ent.Value) error {
switch name {
case revision.FieldType:
v, ok := value.(migrate.RevisionType)
if !ok {
return fmt.Errorf("unexpected type %T for field %s", value, name)
}
m.AddType(v)
return nil
case revision.FieldApplied:
v, ok := value.(int)
if !ok {
return fmt.Errorf("unexpected type %T for field %s", value, name)
}
m.AddApplied(v)
return nil
case revision.FieldTotal:
v, ok := value.(int)
if !ok {
return fmt.Errorf("unexpected type %T for field %s", value, name)
}
m.AddTotal(v)
return nil
case revision.FieldExecutionTime:
v, ok := value.(time.Duration)
if !ok {
return fmt.Errorf("unexpected type %T for field %s", value, name)
}
m.AddExecutionTime(v)
return nil
}
return fmt.Errorf("unknown Revision numeric field %s", name)
}
// ClearedFields returns all nullable fields that were cleared during this
// mutation.
func (m *RevisionMutation) ClearedFields() []string {
var fields []string
if m.FieldCleared(revision.FieldError) {
fields = append(fields, revision.FieldError)
}
if m.FieldCleared(revision.FieldPartialHashes) {
fields = append(fields, revision.FieldPartialHashes)
}
return fields
}
// FieldCleared returns a boolean indicating if a field with the given name was
// cleared in this mutation.
func (m *RevisionMutation) FieldCleared(name string) bool {
_, ok := m.clearedFields[name]
return ok
}
// ClearField clears the value of the field with the given name. It returns an
// error if the field is not defined in the schema.
func (m *RevisionMutation) ClearField(name string) error {
switch name {
case revision.FieldError:
m.ClearError()
return nil
case revision.FieldPartialHashes:
m.ClearPartialHashes()
return nil
}
return fmt.Errorf("unknown Revision nullable field %s", name)
}
// ResetField resets all changes in the mutation for the field with the given name.
// It returns an error if the field is not defined in the schema.
func (m *RevisionMutation) ResetField(name string) error {
switch name {
case revision.FieldDescription:
m.ResetDescription()
return nil
case revision.FieldType:
m.ResetType()
return nil
case revision.FieldApplied:
m.ResetApplied()
return nil
case revision.FieldTotal:
m.ResetTotal()
return nil
case revision.FieldExecutedAt:
m.ResetExecutedAt()
return nil
case revision.FieldExecutionTime:
m.ResetExecutionTime()
return nil
case revision.FieldError:
m.ResetError()
return nil
case revision.FieldHash:
m.ResetHash()
return nil
case revision.FieldPartialHashes:
m.ResetPartialHashes()
return nil
case revision.FieldOperatorVersion:
m.ResetOperatorVersion()
return nil
}
return fmt.Errorf("unknown Revision field %s", name)
}
// AddedEdges returns all edge names that were set/added in this mutation.
func (m *RevisionMutation) AddedEdges() []string {
edges := make([]string, 0, 0)
return edges
}
// AddedIDs returns all IDs (to other nodes) that were added for the given edge
// name in this mutation.
func (m *RevisionMutation) AddedIDs(name string) []ent.Value {
return nil
}
// RemovedEdges returns all edge names that were removed in this mutation.
func (m *RevisionMutation) RemovedEdges() []string {
edges := make([]string, 0, 0)
return edges
}
// RemovedIDs returns all IDs (to other nodes) that were removed for the edge with
// the given name in this mutation.
func (m *RevisionMutation) RemovedIDs(name string) []ent.Value {
return nil
}
// ClearedEdges returns all edge names that were cleared in this mutation.
func (m *RevisionMutation) ClearedEdges() []string {
edges := make([]string, 0, 0)
return edges
}
// EdgeCleared returns a boolean which indicates if the edge with the given name
// was cleared in this mutation.
func (m *RevisionMutation) EdgeCleared(name string) bool {
return false
}
// ClearEdge clears the value of the edge with the given name. It returns an error
// if that edge is not defined in the schema.
func (m *RevisionMutation) ClearEdge(name string) error {
return fmt.Errorf("unknown Revision unique edge %s", name)
}
// ResetEdge resets all changes to the edge with the given name in this mutation.
// It returns an error if the edge is not defined in the schema.
func (m *RevisionMutation) ResetEdge(name string) error {
return fmt.Errorf("unknown Revision edge %s", name)
}
atlas-0.7.2/cmd/atlas/internal/migrate/ent/predicate/ 0000775 0000000 0000000 00000000000 14314555116 0022472 5 ustar 00root root 0000000 0000000 atlas-0.7.2/cmd/atlas/internal/migrate/ent/predicate/predicate.go 0000664 0000000 0000000 00000000613 14314555116 0024761 0 ustar 00root root 0000000 0000000 // Copyright 2021-present The Atlas Authors. All rights reserved.
// This source code is licensed under the Apache 2.0 license found
// in the LICENSE file in the root directory of this source tree.
// Code generated by entc, DO NOT EDIT.
package predicate
import (
"entgo.io/ent/dialect/sql"
)
// Revision is the predicate function for revision builders.
type Revision func(*sql.Selector)
atlas-0.7.2/cmd/atlas/internal/migrate/ent/revision.go 0000664 0000000 0000000 00000016571 14314555116 0022731 0 ustar 00root root 0000000 0000000 // Copyright 2021-present The Atlas Authors. All rights reserved.
// This source code is licensed under the Apache 2.0 license found
// in the LICENSE file in the root directory of this source tree.
// Code generated by entc, DO NOT EDIT.
package ent
import (
"encoding/json"
"fmt"
"strings"
"time"
"ariga.io/atlas/cmd/atlas/internal/migrate/ent/revision"
"ariga.io/atlas/sql/migrate"
"entgo.io/ent/dialect/sql"
)
// Revision is the model entity for the Revision schema.
type Revision struct {
config `json:"-"`
// ID of the ent.
ID string `json:"id,omitempty"`
// Description holds the value of the "description" field.
Description string `json:"description,omitempty"`
// Type holds the value of the "type" field.
Type migrate.RevisionType `json:"type,omitempty"`
// Applied holds the value of the "applied" field.
Applied int `json:"applied,omitempty"`
// Total holds the value of the "total" field.
Total int `json:"total,omitempty"`
// ExecutedAt holds the value of the "executed_at" field.
ExecutedAt time.Time `json:"executed_at,omitempty"`
// ExecutionTime holds the value of the "execution_time" field.
ExecutionTime time.Duration `json:"execution_time,omitempty"`
// Error holds the value of the "error" field.
Error string `json:"error,omitempty"`
// Hash holds the value of the "hash" field.
Hash string `json:"hash,omitempty"`
// PartialHashes holds the value of the "partial_hashes" field.
PartialHashes []string `json:"partial_hashes,omitempty"`
// OperatorVersion holds the value of the "operator_version" field.
OperatorVersion string `json:"operator_version,omitempty"`
}
// scanValues returns the types for scanning values from sql.Rows.
func (*Revision) scanValues(columns []string) ([]interface{}, error) {
values := make([]interface{}, len(columns))
for i := range columns {
switch columns[i] {
case revision.FieldPartialHashes:
values[i] = new([]byte)
case revision.FieldType, revision.FieldApplied, revision.FieldTotal, revision.FieldExecutionTime:
values[i] = new(sql.NullInt64)
case revision.FieldID, revision.FieldDescription, revision.FieldError, revision.FieldHash, revision.FieldOperatorVersion:
values[i] = new(sql.NullString)
case revision.FieldExecutedAt:
values[i] = new(sql.NullTime)
default:
return nil, fmt.Errorf("unexpected column %q for type Revision", columns[i])
}
}
return values, nil
}
// assignValues assigns the values that were returned from sql.Rows (after scanning)
// to the Revision fields.
func (r *Revision) assignValues(columns []string, values []interface{}) error {
if m, n := len(values), len(columns); m < n {
return fmt.Errorf("mismatch number of scan values: %d != %d", m, n)
}
for i := range columns {
switch columns[i] {
case revision.FieldID:
if value, ok := values[i].(*sql.NullString); !ok {
return fmt.Errorf("unexpected type %T for field id", values[i])
} else if value.Valid {
r.ID = value.String
}
case revision.FieldDescription:
if value, ok := values[i].(*sql.NullString); !ok {
return fmt.Errorf("unexpected type %T for field description", values[i])
} else if value.Valid {
r.Description = value.String
}
case revision.FieldType:
if value, ok := values[i].(*sql.NullInt64); !ok {
return fmt.Errorf("unexpected type %T for field type", values[i])
} else if value.Valid {
r.Type = migrate.RevisionType(value.Int64)
}
case revision.FieldApplied:
if value, ok := values[i].(*sql.NullInt64); !ok {
return fmt.Errorf("unexpected type %T for field applied", values[i])
} else if value.Valid {
r.Applied = int(value.Int64)
}
case revision.FieldTotal:
if value, ok := values[i].(*sql.NullInt64); !ok {
return fmt.Errorf("unexpected type %T for field total", values[i])
} else if value.Valid {
r.Total = int(value.Int64)
}
case revision.FieldExecutedAt:
if value, ok := values[i].(*sql.NullTime); !ok {
return fmt.Errorf("unexpected type %T for field executed_at", values[i])
} else if value.Valid {
r.ExecutedAt = value.Time
}
case revision.FieldExecutionTime:
if value, ok := values[i].(*sql.NullInt64); !ok {
return fmt.Errorf("unexpected type %T for field execution_time", values[i])
} else if value.Valid {
r.ExecutionTime = time.Duration(value.Int64)
}
case revision.FieldError:
if value, ok := values[i].(*sql.NullString); !ok {
return fmt.Errorf("unexpected type %T for field error", values[i])
} else if value.Valid {
r.Error = value.String
}
case revision.FieldHash:
if value, ok := values[i].(*sql.NullString); !ok {
return fmt.Errorf("unexpected type %T for field hash", values[i])
} else if value.Valid {
r.Hash = value.String
}
case revision.FieldPartialHashes:
if value, ok := values[i].(*[]byte); !ok {
return fmt.Errorf("unexpected type %T for field partial_hashes", values[i])
} else if value != nil && len(*value) > 0 {
if err := json.Unmarshal(*value, &r.PartialHashes); err != nil {
return fmt.Errorf("unmarshal field partial_hashes: %w", err)
}
}
case revision.FieldOperatorVersion:
if value, ok := values[i].(*sql.NullString); !ok {
return fmt.Errorf("unexpected type %T for field operator_version", values[i])
} else if value.Valid {
r.OperatorVersion = value.String
}
}
}
return nil
}
// Update returns a builder for updating this Revision.
// Note that you need to call Revision.Unwrap() before calling this method if this Revision
// was returned from a transaction, and the transaction was committed or rolled back.
func (r *Revision) Update() *RevisionUpdateOne {
return (&RevisionClient{config: r.config}).UpdateOne(r)
}
// Unwrap unwraps the Revision entity that was returned from a transaction after it was closed,
// so that all future queries will be executed through the driver which created the transaction.
func (r *Revision) Unwrap() *Revision {
_tx, ok := r.config.driver.(*txDriver)
if !ok {
panic("ent: Revision is not a transactional entity")
}
r.config.driver = _tx.drv
return r
}
// String implements the fmt.Stringer.
func (r *Revision) String() string {
var builder strings.Builder
builder.WriteString("Revision(")
builder.WriteString(fmt.Sprintf("id=%v, ", r.ID))
builder.WriteString("description=")
builder.WriteString(r.Description)
builder.WriteString(", ")
builder.WriteString("type=")
builder.WriteString(fmt.Sprintf("%v", r.Type))
builder.WriteString(", ")
builder.WriteString("applied=")
builder.WriteString(fmt.Sprintf("%v", r.Applied))
builder.WriteString(", ")
builder.WriteString("total=")
builder.WriteString(fmt.Sprintf("%v", r.Total))
builder.WriteString(", ")
builder.WriteString("executed_at=")
builder.WriteString(r.ExecutedAt.Format(time.ANSIC))
builder.WriteString(", ")
builder.WriteString("execution_time=")
builder.WriteString(fmt.Sprintf("%v", r.ExecutionTime))
builder.WriteString(", ")
builder.WriteString("error=")
builder.WriteString(r.Error)
builder.WriteString(", ")
builder.WriteString("hash=")
builder.WriteString(r.Hash)
builder.WriteString(", ")
builder.WriteString("partial_hashes=")
builder.WriteString(fmt.Sprintf("%v", r.PartialHashes))
builder.WriteString(", ")
builder.WriteString("operator_version=")
builder.WriteString(r.OperatorVersion)
builder.WriteByte(')')
return builder.String()
}
// Revisions is a parsable slice of Revision.
type Revisions []*Revision
func (r Revisions) config(cfg config) {
for _i := range r {
r[_i].config = cfg
}
}
atlas-0.7.2/cmd/atlas/internal/migrate/ent/revision/ 0000775 0000000 0000000 00000000000 14314555116 0022370 5 ustar 00root root 0000000 0000000 atlas-0.7.2/cmd/atlas/internal/migrate/ent/revision/revision.go 0000664 0000000 0000000 00000005310 14314555116 0024554 0 ustar 00root root 0000000 0000000 // Copyright 2021-present The Atlas Authors. All rights reserved.
// This source code is licensed under the Apache 2.0 license found
// in the LICENSE file in the root directory of this source tree.
// Code generated by entc, DO NOT EDIT.
package revision
import (
"ariga.io/atlas/sql/migrate"
)
const (
// Label holds the string label denoting the revision type in the database.
Label = "revision"
// FieldID holds the string denoting the id field in the database.
FieldID = "version"
// FieldDescription holds the string denoting the description field in the database.
FieldDescription = "description"
// FieldType holds the string denoting the type field in the database.
FieldType = "type"
// FieldApplied holds the string denoting the applied field in the database.
FieldApplied = "applied"
// FieldTotal holds the string denoting the total field in the database.
FieldTotal = "total"
// FieldExecutedAt holds the string denoting the executed_at field in the database.
FieldExecutedAt = "executed_at"
// FieldExecutionTime holds the string denoting the execution_time field in the database.
FieldExecutionTime = "execution_time"
// FieldError holds the string denoting the error field in the database.
FieldError = "error"
// FieldHash holds the string denoting the hash field in the database.
FieldHash = "hash"
// FieldPartialHashes holds the string denoting the partial_hashes field in the database.
FieldPartialHashes = "partial_hashes"
// FieldOperatorVersion holds the string denoting the operator_version field in the database.
FieldOperatorVersion = "operator_version"
// Table holds the table name of the revision in the database.
Table = "atlas_schema_revisions"
)
// Columns holds all SQL columns for revision fields.
var Columns = []string{
FieldID,
FieldDescription,
FieldType,
FieldApplied,
FieldTotal,
FieldExecutedAt,
FieldExecutionTime,
FieldError,
FieldHash,
FieldPartialHashes,
FieldOperatorVersion,
}
// ValidColumn reports if the column name is valid (part of the table columns).
func ValidColumn(column string) bool {
for i := range Columns {
if column == Columns[i] {
return true
}
}
return false
}
var (
// DefaultType holds the default value on creation for the "type" field.
DefaultType migrate.RevisionType
// DefaultApplied holds the default value on creation for the "applied" field.
DefaultApplied int
// AppliedValidator is a validator for the "applied" field. It is called by the builders before save.
AppliedValidator func(int) error
// DefaultTotal holds the default value on creation for the "total" field.
DefaultTotal int
// TotalValidator is a validator for the "total" field. It is called by the builders before save.
TotalValidator func(int) error
)
atlas-0.7.2/cmd/atlas/internal/migrate/ent/revision/where.go 0000664 0000000 0000000 00000075764 14314555116 0024054 0 ustar 00root root 0000000 0000000 // Copyright 2021-present The Atlas Authors. All rights reserved.
// This source code is licensed under the Apache 2.0 license found
// in the LICENSE file in the root directory of this source tree.
// Code generated by entc, DO NOT EDIT.
package revision
import (
"time"
"ariga.io/atlas/cmd/atlas/internal/migrate/ent/predicate"
"ariga.io/atlas/sql/migrate"
"entgo.io/ent/dialect/sql"
)
// ID filters vertices based on their ID field.
func ID(id string) predicate.Revision {
return predicate.Revision(func(s *sql.Selector) {
s.Where(sql.EQ(s.C(FieldID), id))
})
}
// IDEQ applies the EQ predicate on the ID field.
func IDEQ(id string) predicate.Revision {
return predicate.Revision(func(s *sql.Selector) {
s.Where(sql.EQ(s.C(FieldID), id))
})
}
// IDNEQ applies the NEQ predicate on the ID field.
func IDNEQ(id string) predicate.Revision {
return predicate.Revision(func(s *sql.Selector) {
s.Where(sql.NEQ(s.C(FieldID), id))
})
}
// IDIn applies the In predicate on the ID field.
func IDIn(ids ...string) predicate.Revision {
return predicate.Revision(func(s *sql.Selector) {
v := make([]interface{}, len(ids))
for i := range v {
v[i] = ids[i]
}
s.Where(sql.In(s.C(FieldID), v...))
})
}
// IDNotIn applies the NotIn predicate on the ID field.
func IDNotIn(ids ...string) predicate.Revision {
return predicate.Revision(func(s *sql.Selector) {
v := make([]interface{}, len(ids))
for i := range v {
v[i] = ids[i]
}
s.Where(sql.NotIn(s.C(FieldID), v...))
})
}
// IDGT applies the GT predicate on the ID field.
func IDGT(id string) predicate.Revision {
return predicate.Revision(func(s *sql.Selector) {
s.Where(sql.GT(s.C(FieldID), id))
})
}
// IDGTE applies the GTE predicate on the ID field.
func IDGTE(id string) predicate.Revision {
return predicate.Revision(func(s *sql.Selector) {
s.Where(sql.GTE(s.C(FieldID), id))
})
}
// IDLT applies the LT predicate on the ID field.
func IDLT(id string) predicate.Revision {
return predicate.Revision(func(s *sql.Selector) {
s.Where(sql.LT(s.C(FieldID), id))
})
}
// IDLTE applies the LTE predicate on the ID field.
func IDLTE(id string) predicate.Revision {
return predicate.Revision(func(s *sql.Selector) {
s.Where(sql.LTE(s.C(FieldID), id))
})
}
// Description applies equality check predicate on the "description" field. It's identical to DescriptionEQ.
func Description(v string) predicate.Revision {
return predicate.Revision(func(s *sql.Selector) {
s.Where(sql.EQ(s.C(FieldDescription), v))
})
}
// Type applies equality check predicate on the "type" field. It's identical to TypeEQ.
func Type(v migrate.RevisionType) predicate.Revision {
vc := uint(v)
return predicate.Revision(func(s *sql.Selector) {
s.Where(sql.EQ(s.C(FieldType), vc))
})
}
// Applied applies equality check predicate on the "applied" field. It's identical to AppliedEQ.
func Applied(v int) predicate.Revision {
return predicate.Revision(func(s *sql.Selector) {
s.Where(sql.EQ(s.C(FieldApplied), v))
})
}
// Total applies equality check predicate on the "total" field. It's identical to TotalEQ.
func Total(v int) predicate.Revision {
return predicate.Revision(func(s *sql.Selector) {
s.Where(sql.EQ(s.C(FieldTotal), v))
})
}
// ExecutedAt applies equality check predicate on the "executed_at" field. It's identical to ExecutedAtEQ.
func ExecutedAt(v time.Time) predicate.Revision {
return predicate.Revision(func(s *sql.Selector) {
s.Where(sql.EQ(s.C(FieldExecutedAt), v))
})
}
// ExecutionTime applies equality check predicate on the "execution_time" field. It's identical to ExecutionTimeEQ.
func ExecutionTime(v time.Duration) predicate.Revision {
vc := int64(v)
return predicate.Revision(func(s *sql.Selector) {
s.Where(sql.EQ(s.C(FieldExecutionTime), vc))
})
}
// Error applies equality check predicate on the "error" field. It's identical to ErrorEQ.
func Error(v string) predicate.Revision {
return predicate.Revision(func(s *sql.Selector) {
s.Where(sql.EQ(s.C(FieldError), v))
})
}
// Hash applies equality check predicate on the "hash" field. It's identical to HashEQ.
func Hash(v string) predicate.Revision {
return predicate.Revision(func(s *sql.Selector) {
s.Where(sql.EQ(s.C(FieldHash), v))
})
}
// OperatorVersion applies equality check predicate on the "operator_version" field. It's identical to OperatorVersionEQ.
func OperatorVersion(v string) predicate.Revision {
return predicate.Revision(func(s *sql.Selector) {
s.Where(sql.EQ(s.C(FieldOperatorVersion), v))
})
}
// DescriptionEQ applies the EQ predicate on the "description" field.
func DescriptionEQ(v string) predicate.Revision {
return predicate.Revision(func(s *sql.Selector) {
s.Where(sql.EQ(s.C(FieldDescription), v))
})
}
// DescriptionNEQ applies the NEQ predicate on the "description" field.
func DescriptionNEQ(v string) predicate.Revision {
return predicate.Revision(func(s *sql.Selector) {
s.Where(sql.NEQ(s.C(FieldDescription), v))
})
}
// DescriptionIn applies the In predicate on the "description" field.
func DescriptionIn(vs ...string) predicate.Revision {
v := make([]interface{}, len(vs))
for i := range v {
v[i] = vs[i]
}
return predicate.Revision(func(s *sql.Selector) {
// if not arguments were provided, append the FALSE constants,
// since we can't apply "IN ()". This will make this predicate falsy.
if len(v) == 0 {
s.Where(sql.False())
return
}
s.Where(sql.In(s.C(FieldDescription), v...))
})
}
// DescriptionNotIn applies the NotIn predicate on the "description" field.
func DescriptionNotIn(vs ...string) predicate.Revision {
v := make([]interface{}, len(vs))
for i := range v {
v[i] = vs[i]
}
return predicate.Revision(func(s *sql.Selector) {
// if not arguments were provided, append the FALSE constants,
// since we can't apply "IN ()". This will make this predicate falsy.
if len(v) == 0 {
s.Where(sql.False())
return
}
s.Where(sql.NotIn(s.C(FieldDescription), v...))
})
}
// DescriptionGT applies the GT predicate on the "description" field.
func DescriptionGT(v string) predicate.Revision {
return predicate.Revision(func(s *sql.Selector) {
s.Where(sql.GT(s.C(FieldDescription), v))
})
}
// DescriptionGTE applies the GTE predicate on the "description" field.
func DescriptionGTE(v string) predicate.Revision {
return predicate.Revision(func(s *sql.Selector) {
s.Where(sql.GTE(s.C(FieldDescription), v))
})
}
// DescriptionLT applies the LT predicate on the "description" field.
func DescriptionLT(v string) predicate.Revision {
return predicate.Revision(func(s *sql.Selector) {
s.Where(sql.LT(s.C(FieldDescription), v))
})
}
// DescriptionLTE applies the LTE predicate on the "description" field.
func DescriptionLTE(v string) predicate.Revision {
return predicate.Revision(func(s *sql.Selector) {
s.Where(sql.LTE(s.C(FieldDescription), v))
})
}
// DescriptionContains applies the Contains predicate on the "description" field.
func DescriptionContains(v string) predicate.Revision {
return predicate.Revision(func(s *sql.Selector) {
s.Where(sql.Contains(s.C(FieldDescription), v))
})
}
// DescriptionHasPrefix applies the HasPrefix predicate on the "description" field.
func DescriptionHasPrefix(v string) predicate.Revision {
return predicate.Revision(func(s *sql.Selector) {
s.Where(sql.HasPrefix(s.C(FieldDescription), v))
})
}
// DescriptionHasSuffix applies the HasSuffix predicate on the "description" field.
func DescriptionHasSuffix(v string) predicate.Revision {
return predicate.Revision(func(s *sql.Selector) {
s.Where(sql.HasSuffix(s.C(FieldDescription), v))
})
}
// DescriptionEqualFold applies the EqualFold predicate on the "description" field.
func DescriptionEqualFold(v string) predicate.Revision {
return predicate.Revision(func(s *sql.Selector) {
s.Where(sql.EqualFold(s.C(FieldDescription), v))
})
}
// DescriptionContainsFold applies the ContainsFold predicate on the "description" field.
func DescriptionContainsFold(v string) predicate.Revision {
return predicate.Revision(func(s *sql.Selector) {
s.Where(sql.ContainsFold(s.C(FieldDescription), v))
})
}
// TypeEQ applies the EQ predicate on the "type" field.
func TypeEQ(v migrate.RevisionType) predicate.Revision {
vc := uint(v)
return predicate.Revision(func(s *sql.Selector) {
s.Where(sql.EQ(s.C(FieldType), vc))
})
}
// TypeNEQ applies the NEQ predicate on the "type" field.
func TypeNEQ(v migrate.RevisionType) predicate.Revision {
vc := uint(v)
return predicate.Revision(func(s *sql.Selector) {
s.Where(sql.NEQ(s.C(FieldType), vc))
})
}
// TypeIn applies the In predicate on the "type" field.
func TypeIn(vs ...migrate.RevisionType) predicate.Revision {
v := make([]interface{}, len(vs))
for i := range v {
v[i] = uint(vs[i])
}
return predicate.Revision(func(s *sql.Selector) {
// if not arguments were provided, append the FALSE constants,
// since we can't apply "IN ()". This will make this predicate falsy.
if len(v) == 0 {
s.Where(sql.False())
return
}
s.Where(sql.In(s.C(FieldType), v...))
})
}
// TypeNotIn applies the NotIn predicate on the "type" field.
func TypeNotIn(vs ...migrate.RevisionType) predicate.Revision {
v := make([]interface{}, len(vs))
for i := range v {
v[i] = uint(vs[i])
}
return predicate.Revision(func(s *sql.Selector) {
// if not arguments were provided, append the FALSE constants,
// since we can't apply "IN ()". This will make this predicate falsy.
if len(v) == 0 {
s.Where(sql.False())
return
}
s.Where(sql.NotIn(s.C(FieldType), v...))
})
}
// TypeGT applies the GT predicate on the "type" field.
func TypeGT(v migrate.RevisionType) predicate.Revision {
vc := uint(v)
return predicate.Revision(func(s *sql.Selector) {
s.Where(sql.GT(s.C(FieldType), vc))
})
}
// TypeGTE applies the GTE predicate on the "type" field.
func TypeGTE(v migrate.RevisionType) predicate.Revision {
vc := uint(v)
return predicate.Revision(func(s *sql.Selector) {
s.Where(sql.GTE(s.C(FieldType), vc))
})
}
// TypeLT applies the LT predicate on the "type" field.
func TypeLT(v migrate.RevisionType) predicate.Revision {
vc := uint(v)
return predicate.Revision(func(s *sql.Selector) {
s.Where(sql.LT(s.C(FieldType), vc))
})
}
// TypeLTE applies the LTE predicate on the "type" field.
func TypeLTE(v migrate.RevisionType) predicate.Revision {
vc := uint(v)
return predicate.Revision(func(s *sql.Selector) {
s.Where(sql.LTE(s.C(FieldType), vc))
})
}
// AppliedEQ applies the EQ predicate on the "applied" field.
func AppliedEQ(v int) predicate.Revision {
return predicate.Revision(func(s *sql.Selector) {
s.Where(sql.EQ(s.C(FieldApplied), v))
})
}
// AppliedNEQ applies the NEQ predicate on the "applied" field.
func AppliedNEQ(v int) predicate.Revision {
return predicate.Revision(func(s *sql.Selector) {
s.Where(sql.NEQ(s.C(FieldApplied), v))
})
}
// AppliedIn applies the In predicate on the "applied" field.
func AppliedIn(vs ...int) predicate.Revision {
v := make([]interface{}, len(vs))
for i := range v {
v[i] = vs[i]
}
return predicate.Revision(func(s *sql.Selector) {
// if not arguments were provided, append the FALSE constants,
// since we can't apply "IN ()". This will make this predicate falsy.
if len(v) == 0 {
s.Where(sql.False())
return
}
s.Where(sql.In(s.C(FieldApplied), v...))
})
}
// AppliedNotIn applies the NotIn predicate on the "applied" field.
func AppliedNotIn(vs ...int) predicate.Revision {
v := make([]interface{}, len(vs))
for i := range v {
v[i] = vs[i]
}
return predicate.Revision(func(s *sql.Selector) {
// if not arguments were provided, append the FALSE constants,
// since we can't apply "IN ()". This will make this predicate falsy.
if len(v) == 0 {
s.Where(sql.False())
return
}
s.Where(sql.NotIn(s.C(FieldApplied), v...))
})
}
// AppliedGT applies the GT predicate on the "applied" field.
func AppliedGT(v int) predicate.Revision {
return predicate.Revision(func(s *sql.Selector) {
s.Where(sql.GT(s.C(FieldApplied), v))
})
}
// AppliedGTE applies the GTE predicate on the "applied" field.
func AppliedGTE(v int) predicate.Revision {
return predicate.Revision(func(s *sql.Selector) {
s.Where(sql.GTE(s.C(FieldApplied), v))
})
}
// AppliedLT applies the LT predicate on the "applied" field.
func AppliedLT(v int) predicate.Revision {
return predicate.Revision(func(s *sql.Selector) {
s.Where(sql.LT(s.C(FieldApplied), v))
})
}
// AppliedLTE applies the LTE predicate on the "applied" field.
func AppliedLTE(v int) predicate.Revision {
return predicate.Revision(func(s *sql.Selector) {
s.Where(sql.LTE(s.C(FieldApplied), v))
})
}
// TotalEQ applies the EQ predicate on the "total" field.
func TotalEQ(v int) predicate.Revision {
return predicate.Revision(func(s *sql.Selector) {
s.Where(sql.EQ(s.C(FieldTotal), v))
})
}
// TotalNEQ applies the NEQ predicate on the "total" field.
func TotalNEQ(v int) predicate.Revision {
return predicate.Revision(func(s *sql.Selector) {
s.Where(sql.NEQ(s.C(FieldTotal), v))
})
}
// TotalIn applies the In predicate on the "total" field.
func TotalIn(vs ...int) predicate.Revision {
v := make([]interface{}, len(vs))
for i := range v {
v[i] = vs[i]
}
return predicate.Revision(func(s *sql.Selector) {
// if not arguments were provided, append the FALSE constants,
// since we can't apply "IN ()". This will make this predicate falsy.
if len(v) == 0 {
s.Where(sql.False())
return
}
s.Where(sql.In(s.C(FieldTotal), v...))
})
}
// TotalNotIn applies the NotIn predicate on the "total" field.
func TotalNotIn(vs ...int) predicate.Revision {
v := make([]interface{}, len(vs))
for i := range v {
v[i] = vs[i]
}
return predicate.Revision(func(s *sql.Selector) {
// if not arguments were provided, append the FALSE constants,
// since we can't apply "IN ()". This will make this predicate falsy.
if len(v) == 0 {
s.Where(sql.False())
return
}
s.Where(sql.NotIn(s.C(FieldTotal), v...))
})
}
// TotalGT applies the GT predicate on the "total" field.
func TotalGT(v int) predicate.Revision {
return predicate.Revision(func(s *sql.Selector) {
s.Where(sql.GT(s.C(FieldTotal), v))
})
}
// TotalGTE applies the GTE predicate on the "total" field.
func TotalGTE(v int) predicate.Revision {
return predicate.Revision(func(s *sql.Selector) {
s.Where(sql.GTE(s.C(FieldTotal), v))
})
}
// TotalLT applies the LT predicate on the "total" field.
func TotalLT(v int) predicate.Revision {
return predicate.Revision(func(s *sql.Selector) {
s.Where(sql.LT(s.C(FieldTotal), v))
})
}
// TotalLTE applies the LTE predicate on the "total" field.
func TotalLTE(v int) predicate.Revision {
return predicate.Revision(func(s *sql.Selector) {
s.Where(sql.LTE(s.C(FieldTotal), v))
})
}
// ExecutedAtEQ applies the EQ predicate on the "executed_at" field.
func ExecutedAtEQ(v time.Time) predicate.Revision {
return predicate.Revision(func(s *sql.Selector) {
s.Where(sql.EQ(s.C(FieldExecutedAt), v))
})
}
// ExecutedAtNEQ applies the NEQ predicate on the "executed_at" field.
func ExecutedAtNEQ(v time.Time) predicate.Revision {
return predicate.Revision(func(s *sql.Selector) {
s.Where(sql.NEQ(s.C(FieldExecutedAt), v))
})
}
// ExecutedAtIn applies the In predicate on the "executed_at" field.
func ExecutedAtIn(vs ...time.Time) predicate.Revision {
v := make([]interface{}, len(vs))
for i := range v {
v[i] = vs[i]
}
return predicate.Revision(func(s *sql.Selector) {
// if not arguments were provided, append the FALSE constants,
// since we can't apply "IN ()". This will make this predicate falsy.
if len(v) == 0 {
s.Where(sql.False())
return
}
s.Where(sql.In(s.C(FieldExecutedAt), v...))
})
}
// ExecutedAtNotIn applies the NotIn predicate on the "executed_at" field.
func ExecutedAtNotIn(vs ...time.Time) predicate.Revision {
v := make([]interface{}, len(vs))
for i := range v {
v[i] = vs[i]
}
return predicate.Revision(func(s *sql.Selector) {
// if not arguments were provided, append the FALSE constants,
// since we can't apply "IN ()". This will make this predicate falsy.
if len(v) == 0 {
s.Where(sql.False())
return
}
s.Where(sql.NotIn(s.C(FieldExecutedAt), v...))
})
}
// ExecutedAtGT applies the GT predicate on the "executed_at" field.
func ExecutedAtGT(v time.Time) predicate.Revision {
return predicate.Revision(func(s *sql.Selector) {
s.Where(sql.GT(s.C(FieldExecutedAt), v))
})
}
// ExecutedAtGTE applies the GTE predicate on the "executed_at" field.
func ExecutedAtGTE(v time.Time) predicate.Revision {
return predicate.Revision(func(s *sql.Selector) {
s.Where(sql.GTE(s.C(FieldExecutedAt), v))
})
}
// ExecutedAtLT applies the LT predicate on the "executed_at" field.
func ExecutedAtLT(v time.Time) predicate.Revision {
return predicate.Revision(func(s *sql.Selector) {
s.Where(sql.LT(s.C(FieldExecutedAt), v))
})
}
// ExecutedAtLTE applies the LTE predicate on the "executed_at" field.
func ExecutedAtLTE(v time.Time) predicate.Revision {
return predicate.Revision(func(s *sql.Selector) {
s.Where(sql.LTE(s.C(FieldExecutedAt), v))
})
}
// ExecutionTimeEQ applies the EQ predicate on the "execution_time" field.
func ExecutionTimeEQ(v time.Duration) predicate.Revision {
vc := int64(v)
return predicate.Revision(func(s *sql.Selector) {
s.Where(sql.EQ(s.C(FieldExecutionTime), vc))
})
}
// ExecutionTimeNEQ applies the NEQ predicate on the "execution_time" field.
func ExecutionTimeNEQ(v time.Duration) predicate.Revision {
vc := int64(v)
return predicate.Revision(func(s *sql.Selector) {
s.Where(sql.NEQ(s.C(FieldExecutionTime), vc))
})
}
// ExecutionTimeIn applies the In predicate on the "execution_time" field.
func ExecutionTimeIn(vs ...time.Duration) predicate.Revision {
v := make([]interface{}, len(vs))
for i := range v {
v[i] = int64(vs[i])
}
return predicate.Revision(func(s *sql.Selector) {
// if not arguments were provided, append the FALSE constants,
// since we can't apply "IN ()". This will make this predicate falsy.
if len(v) == 0 {
s.Where(sql.False())
return
}
s.Where(sql.In(s.C(FieldExecutionTime), v...))
})
}
// ExecutionTimeNotIn applies the NotIn predicate on the "execution_time" field.
func ExecutionTimeNotIn(vs ...time.Duration) predicate.Revision {
v := make([]interface{}, len(vs))
for i := range v {
v[i] = int64(vs[i])
}
return predicate.Revision(func(s *sql.Selector) {
// if not arguments were provided, append the FALSE constants,
// since we can't apply "IN ()". This will make this predicate falsy.
if len(v) == 0 {
s.Where(sql.False())
return
}
s.Where(sql.NotIn(s.C(FieldExecutionTime), v...))
})
}
// ExecutionTimeGT applies the GT predicate on the "execution_time" field.
func ExecutionTimeGT(v time.Duration) predicate.Revision {
vc := int64(v)
return predicate.Revision(func(s *sql.Selector) {
s.Where(sql.GT(s.C(FieldExecutionTime), vc))
})
}
// ExecutionTimeGTE applies the GTE predicate on the "execution_time" field.
func ExecutionTimeGTE(v time.Duration) predicate.Revision {
vc := int64(v)
return predicate.Revision(func(s *sql.Selector) {
s.Where(sql.GTE(s.C(FieldExecutionTime), vc))
})
}
// ExecutionTimeLT applies the LT predicate on the "execution_time" field.
func ExecutionTimeLT(v time.Duration) predicate.Revision {
vc := int64(v)
return predicate.Revision(func(s *sql.Selector) {
s.Where(sql.LT(s.C(FieldExecutionTime), vc))
})
}
// ExecutionTimeLTE applies the LTE predicate on the "execution_time" field.
func ExecutionTimeLTE(v time.Duration) predicate.Revision {
vc := int64(v)
return predicate.Revision(func(s *sql.Selector) {
s.Where(sql.LTE(s.C(FieldExecutionTime), vc))
})
}
// ErrorEQ applies the EQ predicate on the "error" field.
func ErrorEQ(v string) predicate.Revision {
return predicate.Revision(func(s *sql.Selector) {
s.Where(sql.EQ(s.C(FieldError), v))
})
}
// ErrorNEQ applies the NEQ predicate on the "error" field.
func ErrorNEQ(v string) predicate.Revision {
return predicate.Revision(func(s *sql.Selector) {
s.Where(sql.NEQ(s.C(FieldError), v))
})
}
// ErrorIn applies the In predicate on the "error" field.
func ErrorIn(vs ...string) predicate.Revision {
v := make([]interface{}, len(vs))
for i := range v {
v[i] = vs[i]
}
return predicate.Revision(func(s *sql.Selector) {
// if not arguments were provided, append the FALSE constants,
// since we can't apply "IN ()". This will make this predicate falsy.
if len(v) == 0 {
s.Where(sql.False())
return
}
s.Where(sql.In(s.C(FieldError), v...))
})
}
// ErrorNotIn applies the NotIn predicate on the "error" field.
func ErrorNotIn(vs ...string) predicate.Revision {
v := make([]interface{}, len(vs))
for i := range v {
v[i] = vs[i]
}
return predicate.Revision(func(s *sql.Selector) {
// if not arguments were provided, append the FALSE constants,
// since we can't apply "IN ()". This will make this predicate falsy.
if len(v) == 0 {
s.Where(sql.False())
return
}
s.Where(sql.NotIn(s.C(FieldError), v...))
})
}
// ErrorGT applies the GT predicate on the "error" field.
func ErrorGT(v string) predicate.Revision {
return predicate.Revision(func(s *sql.Selector) {
s.Where(sql.GT(s.C(FieldError), v))
})
}
// ErrorGTE applies the GTE predicate on the "error" field.
func ErrorGTE(v string) predicate.Revision {
return predicate.Revision(func(s *sql.Selector) {
s.Where(sql.GTE(s.C(FieldError), v))
})
}
// ErrorLT applies the LT predicate on the "error" field.
func ErrorLT(v string) predicate.Revision {
return predicate.Revision(func(s *sql.Selector) {
s.Where(sql.LT(s.C(FieldError), v))
})
}
// ErrorLTE applies the LTE predicate on the "error" field.
func ErrorLTE(v string) predicate.Revision {
return predicate.Revision(func(s *sql.Selector) {
s.Where(sql.LTE(s.C(FieldError), v))
})
}
// ErrorContains applies the Contains predicate on the "error" field.
func ErrorContains(v string) predicate.Revision {
return predicate.Revision(func(s *sql.Selector) {
s.Where(sql.Contains(s.C(FieldError), v))
})
}
// ErrorHasPrefix applies the HasPrefix predicate on the "error" field.
func ErrorHasPrefix(v string) predicate.Revision {
return predicate.Revision(func(s *sql.Selector) {
s.Where(sql.HasPrefix(s.C(FieldError), v))
})
}
// ErrorHasSuffix applies the HasSuffix predicate on the "error" field.
func ErrorHasSuffix(v string) predicate.Revision {
return predicate.Revision(func(s *sql.Selector) {
s.Where(sql.HasSuffix(s.C(FieldError), v))
})
}
// ErrorIsNil applies the IsNil predicate on the "error" field.
func ErrorIsNil() predicate.Revision {
return predicate.Revision(func(s *sql.Selector) {
s.Where(sql.IsNull(s.C(FieldError)))
})
}
// ErrorNotNil applies the NotNil predicate on the "error" field.
func ErrorNotNil() predicate.Revision {
return predicate.Revision(func(s *sql.Selector) {
s.Where(sql.NotNull(s.C(FieldError)))
})
}
// ErrorEqualFold applies the EqualFold predicate on the "error" field.
func ErrorEqualFold(v string) predicate.Revision {
return predicate.Revision(func(s *sql.Selector) {
s.Where(sql.EqualFold(s.C(FieldError), v))
})
}
// ErrorContainsFold applies the ContainsFold predicate on the "error" field.
func ErrorContainsFold(v string) predicate.Revision {
return predicate.Revision(func(s *sql.Selector) {
s.Where(sql.ContainsFold(s.C(FieldError), v))
})
}
// HashEQ applies the EQ predicate on the "hash" field.
func HashEQ(v string) predicate.Revision {
return predicate.Revision(func(s *sql.Selector) {
s.Where(sql.EQ(s.C(FieldHash), v))
})
}
// HashNEQ applies the NEQ predicate on the "hash" field.
func HashNEQ(v string) predicate.Revision {
return predicate.Revision(func(s *sql.Selector) {
s.Where(sql.NEQ(s.C(FieldHash), v))
})
}
// HashIn applies the In predicate on the "hash" field.
func HashIn(vs ...string) predicate.Revision {
v := make([]interface{}, len(vs))
for i := range v {
v[i] = vs[i]
}
return predicate.Revision(func(s *sql.Selector) {
// if not arguments were provided, append the FALSE constants,
// since we can't apply "IN ()". This will make this predicate falsy.
if len(v) == 0 {
s.Where(sql.False())
return
}
s.Where(sql.In(s.C(FieldHash), v...))
})
}
// HashNotIn applies the NotIn predicate on the "hash" field.
func HashNotIn(vs ...string) predicate.Revision {
v := make([]interface{}, len(vs))
for i := range v {
v[i] = vs[i]
}
return predicate.Revision(func(s *sql.Selector) {
// if not arguments were provided, append the FALSE constants,
// since we can't apply "IN ()". This will make this predicate falsy.
if len(v) == 0 {
s.Where(sql.False())
return
}
s.Where(sql.NotIn(s.C(FieldHash), v...))
})
}
// HashGT applies the GT predicate on the "hash" field.
func HashGT(v string) predicate.Revision {
return predicate.Revision(func(s *sql.Selector) {
s.Where(sql.GT(s.C(FieldHash), v))
})
}
// HashGTE applies the GTE predicate on the "hash" field.
func HashGTE(v string) predicate.Revision {
return predicate.Revision(func(s *sql.Selector) {
s.Where(sql.GTE(s.C(FieldHash), v))
})
}
// HashLT applies the LT predicate on the "hash" field.
func HashLT(v string) predicate.Revision {
return predicate.Revision(func(s *sql.Selector) {
s.Where(sql.LT(s.C(FieldHash), v))
})
}
// HashLTE applies the LTE predicate on the "hash" field.
func HashLTE(v string) predicate.Revision {
return predicate.Revision(func(s *sql.Selector) {
s.Where(sql.LTE(s.C(FieldHash), v))
})
}
// HashContains applies the Contains predicate on the "hash" field.
func HashContains(v string) predicate.Revision {
return predicate.Revision(func(s *sql.Selector) {
s.Where(sql.Contains(s.C(FieldHash), v))
})
}
// HashHasPrefix applies the HasPrefix predicate on the "hash" field.
func HashHasPrefix(v string) predicate.Revision {
return predicate.Revision(func(s *sql.Selector) {
s.Where(sql.HasPrefix(s.C(FieldHash), v))
})
}
// HashHasSuffix applies the HasSuffix predicate on the "hash" field.
func HashHasSuffix(v string) predicate.Revision {
return predicate.Revision(func(s *sql.Selector) {
s.Where(sql.HasSuffix(s.C(FieldHash), v))
})
}
// HashEqualFold applies the EqualFold predicate on the "hash" field.
func HashEqualFold(v string) predicate.Revision {
return predicate.Revision(func(s *sql.Selector) {
s.Where(sql.EqualFold(s.C(FieldHash), v))
})
}
// HashContainsFold applies the ContainsFold predicate on the "hash" field.
func HashContainsFold(v string) predicate.Revision {
return predicate.Revision(func(s *sql.Selector) {
s.Where(sql.ContainsFold(s.C(FieldHash), v))
})
}
// PartialHashesIsNil applies the IsNil predicate on the "partial_hashes" field.
func PartialHashesIsNil() predicate.Revision {
return predicate.Revision(func(s *sql.Selector) {
s.Where(sql.IsNull(s.C(FieldPartialHashes)))
})
}
// PartialHashesNotNil applies the NotNil predicate on the "partial_hashes" field.
func PartialHashesNotNil() predicate.Revision {
return predicate.Revision(func(s *sql.Selector) {
s.Where(sql.NotNull(s.C(FieldPartialHashes)))
})
}
// OperatorVersionEQ applies the EQ predicate on the "operator_version" field.
func OperatorVersionEQ(v string) predicate.Revision {
return predicate.Revision(func(s *sql.Selector) {
s.Where(sql.EQ(s.C(FieldOperatorVersion), v))
})
}
// OperatorVersionNEQ applies the NEQ predicate on the "operator_version" field.
func OperatorVersionNEQ(v string) predicate.Revision {
return predicate.Revision(func(s *sql.Selector) {
s.Where(sql.NEQ(s.C(FieldOperatorVersion), v))
})
}
// OperatorVersionIn applies the In predicate on the "operator_version" field.
func OperatorVersionIn(vs ...string) predicate.Revision {
v := make([]interface{}, len(vs))
for i := range v {
v[i] = vs[i]
}
return predicate.Revision(func(s *sql.Selector) {
// if not arguments were provided, append the FALSE constants,
// since we can't apply "IN ()". This will make this predicate falsy.
if len(v) == 0 {
s.Where(sql.False())
return
}
s.Where(sql.In(s.C(FieldOperatorVersion), v...))
})
}
// OperatorVersionNotIn applies the NotIn predicate on the "operator_version" field.
func OperatorVersionNotIn(vs ...string) predicate.Revision {
v := make([]interface{}, len(vs))
for i := range v {
v[i] = vs[i]
}
return predicate.Revision(func(s *sql.Selector) {
// if not arguments were provided, append the FALSE constants,
// since we can't apply "IN ()". This will make this predicate falsy.
if len(v) == 0 {
s.Where(sql.False())
return
}
s.Where(sql.NotIn(s.C(FieldOperatorVersion), v...))
})
}
// OperatorVersionGT applies the GT predicate on the "operator_version" field.
func OperatorVersionGT(v string) predicate.Revision {
return predicate.Revision(func(s *sql.Selector) {
s.Where(sql.GT(s.C(FieldOperatorVersion), v))
})
}
// OperatorVersionGTE applies the GTE predicate on the "operator_version" field.
func OperatorVersionGTE(v string) predicate.Revision {
return predicate.Revision(func(s *sql.Selector) {
s.Where(sql.GTE(s.C(FieldOperatorVersion), v))
})
}
// OperatorVersionLT applies the LT predicate on the "operator_version" field.
func OperatorVersionLT(v string) predicate.Revision {
return predicate.Revision(func(s *sql.Selector) {
s.Where(sql.LT(s.C(FieldOperatorVersion), v))
})
}
// OperatorVersionLTE applies the LTE predicate on the "operator_version" field.
func OperatorVersionLTE(v string) predicate.Revision {
return predicate.Revision(func(s *sql.Selector) {
s.Where(sql.LTE(s.C(FieldOperatorVersion), v))
})
}
// OperatorVersionContains applies the Contains predicate on the "operator_version" field.
func OperatorVersionContains(v string) predicate.Revision {
return predicate.Revision(func(s *sql.Selector) {
s.Where(sql.Contains(s.C(FieldOperatorVersion), v))
})
}
// OperatorVersionHasPrefix applies the HasPrefix predicate on the "operator_version" field.
func OperatorVersionHasPrefix(v string) predicate.Revision {
return predicate.Revision(func(s *sql.Selector) {
s.Where(sql.HasPrefix(s.C(FieldOperatorVersion), v))
})
}
// OperatorVersionHasSuffix applies the HasSuffix predicate on the "operator_version" field.
func OperatorVersionHasSuffix(v string) predicate.Revision {
return predicate.Revision(func(s *sql.Selector) {
s.Where(sql.HasSuffix(s.C(FieldOperatorVersion), v))
})
}
// OperatorVersionEqualFold applies the EqualFold predicate on the "operator_version" field.
func OperatorVersionEqualFold(v string) predicate.Revision {
return predicate.Revision(func(s *sql.Selector) {
s.Where(sql.EqualFold(s.C(FieldOperatorVersion), v))
})
}
// OperatorVersionContainsFold applies the ContainsFold predicate on the "operator_version" field.
func OperatorVersionContainsFold(v string) predicate.Revision {
return predicate.Revision(func(s *sql.Selector) {
s.Where(sql.ContainsFold(s.C(FieldOperatorVersion), v))
})
}
// And groups predicates with the AND operator between them.
func And(predicates ...predicate.Revision) predicate.Revision {
return predicate.Revision(func(s *sql.Selector) {
s1 := s.Clone().SetP(nil)
for _, p := range predicates {
p(s1)
}
s.Where(s1.P())
})
}
// Or groups predicates with the OR operator between them.
func Or(predicates ...predicate.Revision) predicate.Revision {
return predicate.Revision(func(s *sql.Selector) {
s1 := s.Clone().SetP(nil)
for i, p := range predicates {
if i > 0 {
s1.Or()
}
p(s1)
}
s.Where(s1.P())
})
}
// Not applies the not operator on the given predicate.
func Not(p predicate.Revision) predicate.Revision {
return predicate.Revision(func(s *sql.Selector) {
p(s.Not())
})
}
atlas-0.7.2/cmd/atlas/internal/migrate/ent/revision_create.go 0000664 0000000 0000000 00000106105 14314555116 0024245 0 ustar 00root root 0000000 0000000 // Copyright 2021-present The Atlas Authors. All rights reserved.
// This source code is licensed under the Apache 2.0 license found
// in the LICENSE file in the root directory of this source tree.
// Code generated by entc, DO NOT EDIT.
package ent
import (
"context"
"errors"
"fmt"
"time"
"ariga.io/atlas/cmd/atlas/internal/migrate/ent/revision"
"ariga.io/atlas/sql/migrate"
"entgo.io/ent/dialect"
"entgo.io/ent/dialect/sql"
"entgo.io/ent/dialect/sql/sqlgraph"
"entgo.io/ent/schema/field"
)
// RevisionCreate is the builder for creating a Revision entity.
type RevisionCreate struct {
config
mutation *RevisionMutation
hooks []Hook
conflict []sql.ConflictOption
}
// SetDescription sets the "description" field.
func (rc *RevisionCreate) SetDescription(s string) *RevisionCreate {
rc.mutation.SetDescription(s)
return rc
}
// SetType sets the "type" field.
func (rc *RevisionCreate) SetType(mt migrate.RevisionType) *RevisionCreate {
rc.mutation.SetType(mt)
return rc
}
// SetNillableType sets the "type" field if the given value is not nil.
func (rc *RevisionCreate) SetNillableType(mt *migrate.RevisionType) *RevisionCreate {
if mt != nil {
rc.SetType(*mt)
}
return rc
}
// SetApplied sets the "applied" field.
func (rc *RevisionCreate) SetApplied(i int) *RevisionCreate {
rc.mutation.SetApplied(i)
return rc
}
// SetNillableApplied sets the "applied" field if the given value is not nil.
func (rc *RevisionCreate) SetNillableApplied(i *int) *RevisionCreate {
if i != nil {
rc.SetApplied(*i)
}
return rc
}
// SetTotal sets the "total" field.
func (rc *RevisionCreate) SetTotal(i int) *RevisionCreate {
rc.mutation.SetTotal(i)
return rc
}
// SetNillableTotal sets the "total" field if the given value is not nil.
func (rc *RevisionCreate) SetNillableTotal(i *int) *RevisionCreate {
if i != nil {
rc.SetTotal(*i)
}
return rc
}
// SetExecutedAt sets the "executed_at" field.
func (rc *RevisionCreate) SetExecutedAt(t time.Time) *RevisionCreate {
rc.mutation.SetExecutedAt(t)
return rc
}
// SetExecutionTime sets the "execution_time" field.
func (rc *RevisionCreate) SetExecutionTime(t time.Duration) *RevisionCreate {
rc.mutation.SetExecutionTime(t)
return rc
}
// SetError sets the "error" field.
func (rc *RevisionCreate) SetError(s string) *RevisionCreate {
rc.mutation.SetError(s)
return rc
}
// SetNillableError sets the "error" field if the given value is not nil.
func (rc *RevisionCreate) SetNillableError(s *string) *RevisionCreate {
if s != nil {
rc.SetError(*s)
}
return rc
}
// SetHash sets the "hash" field.
func (rc *RevisionCreate) SetHash(s string) *RevisionCreate {
rc.mutation.SetHash(s)
return rc
}
// SetPartialHashes sets the "partial_hashes" field.
func (rc *RevisionCreate) SetPartialHashes(s []string) *RevisionCreate {
rc.mutation.SetPartialHashes(s)
return rc
}
// SetOperatorVersion sets the "operator_version" field.
func (rc *RevisionCreate) SetOperatorVersion(s string) *RevisionCreate {
rc.mutation.SetOperatorVersion(s)
return rc
}
// SetID sets the "id" field.
func (rc *RevisionCreate) SetID(s string) *RevisionCreate {
rc.mutation.SetID(s)
return rc
}
// Mutation returns the RevisionMutation object of the builder.
func (rc *RevisionCreate) Mutation() *RevisionMutation {
return rc.mutation
}
// Save creates the Revision in the database.
func (rc *RevisionCreate) Save(ctx context.Context) (*Revision, error) {
var (
err error
node *Revision
)
rc.defaults()
if len(rc.hooks) == 0 {
if err = rc.check(); err != nil {
return nil, err
}
node, err = rc.sqlSave(ctx)
} else {
var mut Mutator = MutateFunc(func(ctx context.Context, m Mutation) (Value, error) {
mutation, ok := m.(*RevisionMutation)
if !ok {
return nil, fmt.Errorf("unexpected mutation type %T", m)
}
if err = rc.check(); err != nil {
return nil, err
}
rc.mutation = mutation
if node, err = rc.sqlSave(ctx); err != nil {
return nil, err
}
mutation.id = &node.ID
mutation.done = true
return node, err
})
for i := len(rc.hooks) - 1; i >= 0; i-- {
if rc.hooks[i] == nil {
return nil, fmt.Errorf("ent: uninitialized hook (forgotten import ent/runtime?)")
}
mut = rc.hooks[i](mut)
}
v, err := mut.Mutate(ctx, rc.mutation)
if err != nil {
return nil, err
}
nv, ok := v.(*Revision)
if !ok {
return nil, fmt.Errorf("unexpected node type %T returned from RevisionMutation", v)
}
node = nv
}
return node, err
}
// SaveX calls Save and panics if Save returns an error.
func (rc *RevisionCreate) SaveX(ctx context.Context) *Revision {
v, err := rc.Save(ctx)
if err != nil {
panic(err)
}
return v
}
// Exec executes the query.
func (rc *RevisionCreate) Exec(ctx context.Context) error {
_, err := rc.Save(ctx)
return err
}
// ExecX is like Exec, but panics if an error occurs.
func (rc *RevisionCreate) ExecX(ctx context.Context) {
if err := rc.Exec(ctx); err != nil {
panic(err)
}
}
// defaults sets the default values of the builder before save.
func (rc *RevisionCreate) defaults() {
if _, ok := rc.mutation.GetType(); !ok {
v := revision.DefaultType
rc.mutation.SetType(v)
}
if _, ok := rc.mutation.Applied(); !ok {
v := revision.DefaultApplied
rc.mutation.SetApplied(v)
}
if _, ok := rc.mutation.Total(); !ok {
v := revision.DefaultTotal
rc.mutation.SetTotal(v)
}
}
// check runs all checks and user-defined validators on the builder.
func (rc *RevisionCreate) check() error {
if _, ok := rc.mutation.Description(); !ok {
return &ValidationError{Name: "description", err: errors.New(`ent: missing required field "Revision.description"`)}
}
if _, ok := rc.mutation.GetType(); !ok {
return &ValidationError{Name: "type", err: errors.New(`ent: missing required field "Revision.type"`)}
}
if _, ok := rc.mutation.Applied(); !ok {
return &ValidationError{Name: "applied", err: errors.New(`ent: missing required field "Revision.applied"`)}
}
if v, ok := rc.mutation.Applied(); ok {
if err := revision.AppliedValidator(v); err != nil {
return &ValidationError{Name: "applied", err: fmt.Errorf(`ent: validator failed for field "Revision.applied": %w`, err)}
}
}
if _, ok := rc.mutation.Total(); !ok {
return &ValidationError{Name: "total", err: errors.New(`ent: missing required field "Revision.total"`)}
}
if v, ok := rc.mutation.Total(); ok {
if err := revision.TotalValidator(v); err != nil {
return &ValidationError{Name: "total", err: fmt.Errorf(`ent: validator failed for field "Revision.total": %w`, err)}
}
}
if _, ok := rc.mutation.ExecutedAt(); !ok {
return &ValidationError{Name: "executed_at", err: errors.New(`ent: missing required field "Revision.executed_at"`)}
}
if _, ok := rc.mutation.ExecutionTime(); !ok {
return &ValidationError{Name: "execution_time", err: errors.New(`ent: missing required field "Revision.execution_time"`)}
}
if _, ok := rc.mutation.Hash(); !ok {
return &ValidationError{Name: "hash", err: errors.New(`ent: missing required field "Revision.hash"`)}
}
if _, ok := rc.mutation.OperatorVersion(); !ok {
return &ValidationError{Name: "operator_version", err: errors.New(`ent: missing required field "Revision.operator_version"`)}
}
return nil
}
func (rc *RevisionCreate) sqlSave(ctx context.Context) (*Revision, error) {
_node, _spec := rc.createSpec()
if err := sqlgraph.CreateNode(ctx, rc.driver, _spec); err != nil {
if sqlgraph.IsConstraintError(err) {
err = &ConstraintError{msg: err.Error(), wrap: err}
}
return nil, err
}
if _spec.ID.Value != nil {
if id, ok := _spec.ID.Value.(string); ok {
_node.ID = id
} else {
return nil, fmt.Errorf("unexpected Revision.ID type: %T", _spec.ID.Value)
}
}
return _node, nil
}
func (rc *RevisionCreate) createSpec() (*Revision, *sqlgraph.CreateSpec) {
var (
_node = &Revision{config: rc.config}
_spec = &sqlgraph.CreateSpec{
Table: revision.Table,
ID: &sqlgraph.FieldSpec{
Type: field.TypeString,
Column: revision.FieldID,
},
}
)
_spec.Schema = rc.schemaConfig.Revision
_spec.OnConflict = rc.conflict
if id, ok := rc.mutation.ID(); ok {
_node.ID = id
_spec.ID.Value = id
}
if value, ok := rc.mutation.Description(); ok {
_spec.Fields = append(_spec.Fields, &sqlgraph.FieldSpec{
Type: field.TypeString,
Value: value,
Column: revision.FieldDescription,
})
_node.Description = value
}
if value, ok := rc.mutation.GetType(); ok {
_spec.Fields = append(_spec.Fields, &sqlgraph.FieldSpec{
Type: field.TypeUint,
Value: value,
Column: revision.FieldType,
})
_node.Type = value
}
if value, ok := rc.mutation.Applied(); ok {
_spec.Fields = append(_spec.Fields, &sqlgraph.FieldSpec{
Type: field.TypeInt,
Value: value,
Column: revision.FieldApplied,
})
_node.Applied = value
}
if value, ok := rc.mutation.Total(); ok {
_spec.Fields = append(_spec.Fields, &sqlgraph.FieldSpec{
Type: field.TypeInt,
Value: value,
Column: revision.FieldTotal,
})
_node.Total = value
}
if value, ok := rc.mutation.ExecutedAt(); ok {
_spec.Fields = append(_spec.Fields, &sqlgraph.FieldSpec{
Type: field.TypeTime,
Value: value,
Column: revision.FieldExecutedAt,
})
_node.ExecutedAt = value
}
if value, ok := rc.mutation.ExecutionTime(); ok {
_spec.Fields = append(_spec.Fields, &sqlgraph.FieldSpec{
Type: field.TypeInt64,
Value: value,
Column: revision.FieldExecutionTime,
})
_node.ExecutionTime = value
}
if value, ok := rc.mutation.Error(); ok {
_spec.Fields = append(_spec.Fields, &sqlgraph.FieldSpec{
Type: field.TypeString,
Value: value,
Column: revision.FieldError,
})
_node.Error = value
}
if value, ok := rc.mutation.Hash(); ok {
_spec.Fields = append(_spec.Fields, &sqlgraph.FieldSpec{
Type: field.TypeString,
Value: value,
Column: revision.FieldHash,
})
_node.Hash = value
}
if value, ok := rc.mutation.PartialHashes(); ok {
_spec.Fields = append(_spec.Fields, &sqlgraph.FieldSpec{
Type: field.TypeJSON,
Value: value,
Column: revision.FieldPartialHashes,
})
_node.PartialHashes = value
}
if value, ok := rc.mutation.OperatorVersion(); ok {
_spec.Fields = append(_spec.Fields, &sqlgraph.FieldSpec{
Type: field.TypeString,
Value: value,
Column: revision.FieldOperatorVersion,
})
_node.OperatorVersion = value
}
return _node, _spec
}
// OnConflict allows configuring the `ON CONFLICT` / `ON DUPLICATE KEY` clause
// of the `INSERT` statement. For example:
//
// client.Revision.Create().
// SetDescription(v).
// OnConflict(
// // Update the row with the new values
// // the was proposed for insertion.
// sql.ResolveWithNewValues(),
// ).
// // Override some of the fields with custom
// // update values.
// Update(func(u *ent.RevisionUpsert) {
// SetDescription(v+v).
// }).
// Exec(ctx)
func (rc *RevisionCreate) OnConflict(opts ...sql.ConflictOption) *RevisionUpsertOne {
rc.conflict = opts
return &RevisionUpsertOne{
create: rc,
}
}
// OnConflictColumns calls `OnConflict` and configures the columns
// as conflict target. Using this option is equivalent to using:
//
// client.Revision.Create().
// OnConflict(sql.ConflictColumns(columns...)).
// Exec(ctx)
func (rc *RevisionCreate) OnConflictColumns(columns ...string) *RevisionUpsertOne {
rc.conflict = append(rc.conflict, sql.ConflictColumns(columns...))
return &RevisionUpsertOne{
create: rc,
}
}
type (
// RevisionUpsertOne is the builder for "upsert"-ing
// one Revision node.
RevisionUpsertOne struct {
create *RevisionCreate
}
// RevisionUpsert is the "OnConflict" setter.
RevisionUpsert struct {
*sql.UpdateSet
}
)
// SetDescription sets the "description" field.
func (u *RevisionUpsert) SetDescription(v string) *RevisionUpsert {
u.Set(revision.FieldDescription, v)
return u
}
// UpdateDescription sets the "description" field to the value that was provided on create.
func (u *RevisionUpsert) UpdateDescription() *RevisionUpsert {
u.SetExcluded(revision.FieldDescription)
return u
}
// SetType sets the "type" field.
func (u *RevisionUpsert) SetType(v migrate.RevisionType) *RevisionUpsert {
u.Set(revision.FieldType, v)
return u
}
// UpdateType sets the "type" field to the value that was provided on create.
func (u *RevisionUpsert) UpdateType() *RevisionUpsert {
u.SetExcluded(revision.FieldType)
return u
}
// AddType adds v to the "type" field.
func (u *RevisionUpsert) AddType(v migrate.RevisionType) *RevisionUpsert {
u.Add(revision.FieldType, v)
return u
}
// SetApplied sets the "applied" field.
func (u *RevisionUpsert) SetApplied(v int) *RevisionUpsert {
u.Set(revision.FieldApplied, v)
return u
}
// UpdateApplied sets the "applied" field to the value that was provided on create.
func (u *RevisionUpsert) UpdateApplied() *RevisionUpsert {
u.SetExcluded(revision.FieldApplied)
return u
}
// AddApplied adds v to the "applied" field.
func (u *RevisionUpsert) AddApplied(v int) *RevisionUpsert {
u.Add(revision.FieldApplied, v)
return u
}
// SetTotal sets the "total" field.
func (u *RevisionUpsert) SetTotal(v int) *RevisionUpsert {
u.Set(revision.FieldTotal, v)
return u
}
// UpdateTotal sets the "total" field to the value that was provided on create.
func (u *RevisionUpsert) UpdateTotal() *RevisionUpsert {
u.SetExcluded(revision.FieldTotal)
return u
}
// AddTotal adds v to the "total" field.
func (u *RevisionUpsert) AddTotal(v int) *RevisionUpsert {
u.Add(revision.FieldTotal, v)
return u
}
// SetExecutedAt sets the "executed_at" field.
func (u *RevisionUpsert) SetExecutedAt(v time.Time) *RevisionUpsert {
u.Set(revision.FieldExecutedAt, v)
return u
}
// UpdateExecutedAt sets the "executed_at" field to the value that was provided on create.
func (u *RevisionUpsert) UpdateExecutedAt() *RevisionUpsert {
u.SetExcluded(revision.FieldExecutedAt)
return u
}
// SetExecutionTime sets the "execution_time" field.
func (u *RevisionUpsert) SetExecutionTime(v time.Duration) *RevisionUpsert {
u.Set(revision.FieldExecutionTime, v)
return u
}
// UpdateExecutionTime sets the "execution_time" field to the value that was provided on create.
func (u *RevisionUpsert) UpdateExecutionTime() *RevisionUpsert {
u.SetExcluded(revision.FieldExecutionTime)
return u
}
// AddExecutionTime adds v to the "execution_time" field.
func (u *RevisionUpsert) AddExecutionTime(v time.Duration) *RevisionUpsert {
u.Add(revision.FieldExecutionTime, v)
return u
}
// SetError sets the "error" field.
func (u *RevisionUpsert) SetError(v string) *RevisionUpsert {
u.Set(revision.FieldError, v)
return u
}
// UpdateError sets the "error" field to the value that was provided on create.
func (u *RevisionUpsert) UpdateError() *RevisionUpsert {
u.SetExcluded(revision.FieldError)
return u
}
// ClearError clears the value of the "error" field.
func (u *RevisionUpsert) ClearError() *RevisionUpsert {
u.SetNull(revision.FieldError)
return u
}
// SetHash sets the "hash" field.
func (u *RevisionUpsert) SetHash(v string) *RevisionUpsert {
u.Set(revision.FieldHash, v)
return u
}
// UpdateHash sets the "hash" field to the value that was provided on create.
func (u *RevisionUpsert) UpdateHash() *RevisionUpsert {
u.SetExcluded(revision.FieldHash)
return u
}
// SetPartialHashes sets the "partial_hashes" field.
func (u *RevisionUpsert) SetPartialHashes(v []string) *RevisionUpsert {
u.Set(revision.FieldPartialHashes, v)
return u
}
// UpdatePartialHashes sets the "partial_hashes" field to the value that was provided on create.
func (u *RevisionUpsert) UpdatePartialHashes() *RevisionUpsert {
u.SetExcluded(revision.FieldPartialHashes)
return u
}
// ClearPartialHashes clears the value of the "partial_hashes" field.
func (u *RevisionUpsert) ClearPartialHashes() *RevisionUpsert {
u.SetNull(revision.FieldPartialHashes)
return u
}
// SetOperatorVersion sets the "operator_version" field.
func (u *RevisionUpsert) SetOperatorVersion(v string) *RevisionUpsert {
u.Set(revision.FieldOperatorVersion, v)
return u
}
// UpdateOperatorVersion sets the "operator_version" field to the value that was provided on create.
func (u *RevisionUpsert) UpdateOperatorVersion() *RevisionUpsert {
u.SetExcluded(revision.FieldOperatorVersion)
return u
}
// UpdateNewValues updates the mutable fields using the new values that were set on create except the ID field.
// Using this option is equivalent to using:
//
// client.Revision.Create().
// OnConflict(
// sql.ResolveWithNewValues(),
// sql.ResolveWith(func(u *sql.UpdateSet) {
// u.SetIgnore(revision.FieldID)
// }),
// ).
// Exec(ctx)
func (u *RevisionUpsertOne) UpdateNewValues() *RevisionUpsertOne {
u.create.conflict = append(u.create.conflict, sql.ResolveWithNewValues())
u.create.conflict = append(u.create.conflict, sql.ResolveWith(func(s *sql.UpdateSet) {
if _, exists := u.create.mutation.ID(); exists {
s.SetIgnore(revision.FieldID)
}
if _, exists := u.create.mutation.Description(); exists {
s.SetIgnore(revision.FieldDescription)
}
if _, exists := u.create.mutation.ExecutedAt(); exists {
s.SetIgnore(revision.FieldExecutedAt)
}
}))
return u
}
// Ignore sets each column to itself in case of conflict.
// Using this option is equivalent to using:
//
// client.Revision.Create().
// OnConflict(sql.ResolveWithIgnore()).
// Exec(ctx)
func (u *RevisionUpsertOne) Ignore() *RevisionUpsertOne {
u.create.conflict = append(u.create.conflict, sql.ResolveWithIgnore())
return u
}
// DoNothing configures the conflict_action to `DO NOTHING`.
// Supported only by SQLite and PostgreSQL.
func (u *RevisionUpsertOne) DoNothing() *RevisionUpsertOne {
u.create.conflict = append(u.create.conflict, sql.DoNothing())
return u
}
// Update allows overriding fields `UPDATE` values. See the RevisionCreate.OnConflict
// documentation for more info.
func (u *RevisionUpsertOne) Update(set func(*RevisionUpsert)) *RevisionUpsertOne {
u.create.conflict = append(u.create.conflict, sql.ResolveWith(func(update *sql.UpdateSet) {
set(&RevisionUpsert{UpdateSet: update})
}))
return u
}
// SetDescription sets the "description" field.
func (u *RevisionUpsertOne) SetDescription(v string) *RevisionUpsertOne {
return u.Update(func(s *RevisionUpsert) {
s.SetDescription(v)
})
}
// UpdateDescription sets the "description" field to the value that was provided on create.
func (u *RevisionUpsertOne) UpdateDescription() *RevisionUpsertOne {
return u.Update(func(s *RevisionUpsert) {
s.UpdateDescription()
})
}
// SetType sets the "type" field.
func (u *RevisionUpsertOne) SetType(v migrate.RevisionType) *RevisionUpsertOne {
return u.Update(func(s *RevisionUpsert) {
s.SetType(v)
})
}
// AddType adds v to the "type" field.
func (u *RevisionUpsertOne) AddType(v migrate.RevisionType) *RevisionUpsertOne {
return u.Update(func(s *RevisionUpsert) {
s.AddType(v)
})
}
// UpdateType sets the "type" field to the value that was provided on create.
func (u *RevisionUpsertOne) UpdateType() *RevisionUpsertOne {
return u.Update(func(s *RevisionUpsert) {
s.UpdateType()
})
}
// SetApplied sets the "applied" field.
func (u *RevisionUpsertOne) SetApplied(v int) *RevisionUpsertOne {
return u.Update(func(s *RevisionUpsert) {
s.SetApplied(v)
})
}
// AddApplied adds v to the "applied" field.
func (u *RevisionUpsertOne) AddApplied(v int) *RevisionUpsertOne {
return u.Update(func(s *RevisionUpsert) {
s.AddApplied(v)
})
}
// UpdateApplied sets the "applied" field to the value that was provided on create.
func (u *RevisionUpsertOne) UpdateApplied() *RevisionUpsertOne {
return u.Update(func(s *RevisionUpsert) {
s.UpdateApplied()
})
}
// SetTotal sets the "total" field.
func (u *RevisionUpsertOne) SetTotal(v int) *RevisionUpsertOne {
return u.Update(func(s *RevisionUpsert) {
s.SetTotal(v)
})
}
// AddTotal adds v to the "total" field.
func (u *RevisionUpsertOne) AddTotal(v int) *RevisionUpsertOne {
return u.Update(func(s *RevisionUpsert) {
s.AddTotal(v)
})
}
// UpdateTotal sets the "total" field to the value that was provided on create.
func (u *RevisionUpsertOne) UpdateTotal() *RevisionUpsertOne {
return u.Update(func(s *RevisionUpsert) {
s.UpdateTotal()
})
}
// SetExecutedAt sets the "executed_at" field.
func (u *RevisionUpsertOne) SetExecutedAt(v time.Time) *RevisionUpsertOne {
return u.Update(func(s *RevisionUpsert) {
s.SetExecutedAt(v)
})
}
// UpdateExecutedAt sets the "executed_at" field to the value that was provided on create.
func (u *RevisionUpsertOne) UpdateExecutedAt() *RevisionUpsertOne {
return u.Update(func(s *RevisionUpsert) {
s.UpdateExecutedAt()
})
}
// SetExecutionTime sets the "execution_time" field.
func (u *RevisionUpsertOne) SetExecutionTime(v time.Duration) *RevisionUpsertOne {
return u.Update(func(s *RevisionUpsert) {
s.SetExecutionTime(v)
})
}
// AddExecutionTime adds v to the "execution_time" field.
func (u *RevisionUpsertOne) AddExecutionTime(v time.Duration) *RevisionUpsertOne {
return u.Update(func(s *RevisionUpsert) {
s.AddExecutionTime(v)
})
}
// UpdateExecutionTime sets the "execution_time" field to the value that was provided on create.
func (u *RevisionUpsertOne) UpdateExecutionTime() *RevisionUpsertOne {
return u.Update(func(s *RevisionUpsert) {
s.UpdateExecutionTime()
})
}
// SetError sets the "error" field.
func (u *RevisionUpsertOne) SetError(v string) *RevisionUpsertOne {
return u.Update(func(s *RevisionUpsert) {
s.SetError(v)
})
}
// UpdateError sets the "error" field to the value that was provided on create.
func (u *RevisionUpsertOne) UpdateError() *RevisionUpsertOne {
return u.Update(func(s *RevisionUpsert) {
s.UpdateError()
})
}
// ClearError clears the value of the "error" field.
func (u *RevisionUpsertOne) ClearError() *RevisionUpsertOne {
return u.Update(func(s *RevisionUpsert) {
s.ClearError()
})
}
// SetHash sets the "hash" field.
func (u *RevisionUpsertOne) SetHash(v string) *RevisionUpsertOne {
return u.Update(func(s *RevisionUpsert) {
s.SetHash(v)
})
}
// UpdateHash sets the "hash" field to the value that was provided on create.
func (u *RevisionUpsertOne) UpdateHash() *RevisionUpsertOne {
return u.Update(func(s *RevisionUpsert) {
s.UpdateHash()
})
}
// SetPartialHashes sets the "partial_hashes" field.
func (u *RevisionUpsertOne) SetPartialHashes(v []string) *RevisionUpsertOne {
return u.Update(func(s *RevisionUpsert) {
s.SetPartialHashes(v)
})
}
// UpdatePartialHashes sets the "partial_hashes" field to the value that was provided on create.
func (u *RevisionUpsertOne) UpdatePartialHashes() *RevisionUpsertOne {
return u.Update(func(s *RevisionUpsert) {
s.UpdatePartialHashes()
})
}
// ClearPartialHashes clears the value of the "partial_hashes" field.
func (u *RevisionUpsertOne) ClearPartialHashes() *RevisionUpsertOne {
return u.Update(func(s *RevisionUpsert) {
s.ClearPartialHashes()
})
}
// SetOperatorVersion sets the "operator_version" field.
func (u *RevisionUpsertOne) SetOperatorVersion(v string) *RevisionUpsertOne {
return u.Update(func(s *RevisionUpsert) {
s.SetOperatorVersion(v)
})
}
// UpdateOperatorVersion sets the "operator_version" field to the value that was provided on create.
func (u *RevisionUpsertOne) UpdateOperatorVersion() *RevisionUpsertOne {
return u.Update(func(s *RevisionUpsert) {
s.UpdateOperatorVersion()
})
}
// Exec executes the query.
func (u *RevisionUpsertOne) Exec(ctx context.Context) error {
if len(u.create.conflict) == 0 {
return errors.New("ent: missing options for RevisionCreate.OnConflict")
}
return u.create.Exec(ctx)
}
// ExecX is like Exec, but panics if an error occurs.
func (u *RevisionUpsertOne) ExecX(ctx context.Context) {
if err := u.create.Exec(ctx); err != nil {
panic(err)
}
}
// Exec executes the UPSERT query and returns the inserted/updated ID.
func (u *RevisionUpsertOne) ID(ctx context.Context) (id string, err error) {
if u.create.driver.Dialect() == dialect.MySQL {
// In case of "ON CONFLICT", there is no way to get back non-numeric ID
// fields from the database since MySQL does not support the RETURNING clause.
return id, errors.New("ent: RevisionUpsertOne.ID is not supported by MySQL driver. Use RevisionUpsertOne.Exec instead")
}
node, err := u.create.Save(ctx)
if err != nil {
return id, err
}
return node.ID, nil
}
// IDX is like ID, but panics if an error occurs.
func (u *RevisionUpsertOne) IDX(ctx context.Context) string {
id, err := u.ID(ctx)
if err != nil {
panic(err)
}
return id
}
// RevisionCreateBulk is the builder for creating many Revision entities in bulk.
type RevisionCreateBulk struct {
config
builders []*RevisionCreate
conflict []sql.ConflictOption
}
// Save creates the Revision entities in the database.
func (rcb *RevisionCreateBulk) Save(ctx context.Context) ([]*Revision, error) {
specs := make([]*sqlgraph.CreateSpec, len(rcb.builders))
nodes := make([]*Revision, len(rcb.builders))
mutators := make([]Mutator, len(rcb.builders))
for i := range rcb.builders {
func(i int, root context.Context) {
builder := rcb.builders[i]
builder.defaults()
var mut Mutator = MutateFunc(func(ctx context.Context, m Mutation) (Value, error) {
mutation, ok := m.(*RevisionMutation)
if !ok {
return nil, fmt.Errorf("unexpected mutation type %T", m)
}
if err := builder.check(); err != nil {
return nil, err
}
builder.mutation = mutation
nodes[i], specs[i] = builder.createSpec()
var err error
if i < len(mutators)-1 {
_, err = mutators[i+1].Mutate(root, rcb.builders[i+1].mutation)
} else {
spec := &sqlgraph.BatchCreateSpec{Nodes: specs}
spec.OnConflict = rcb.conflict
// Invoke the actual operation on the latest mutation in the chain.
if err = sqlgraph.BatchCreate(ctx, rcb.driver, spec); err != nil {
if sqlgraph.IsConstraintError(err) {
err = &ConstraintError{msg: err.Error(), wrap: err}
}
}
}
if err != nil {
return nil, err
}
mutation.id = &nodes[i].ID
mutation.done = true
return nodes[i], nil
})
for i := len(builder.hooks) - 1; i >= 0; i-- {
mut = builder.hooks[i](mut)
}
mutators[i] = mut
}(i, ctx)
}
if len(mutators) > 0 {
if _, err := mutators[0].Mutate(ctx, rcb.builders[0].mutation); err != nil {
return nil, err
}
}
return nodes, nil
}
// SaveX is like Save, but panics if an error occurs.
func (rcb *RevisionCreateBulk) SaveX(ctx context.Context) []*Revision {
v, err := rcb.Save(ctx)
if err != nil {
panic(err)
}
return v
}
// Exec executes the query.
func (rcb *RevisionCreateBulk) Exec(ctx context.Context) error {
_, err := rcb.Save(ctx)
return err
}
// ExecX is like Exec, but panics if an error occurs.
func (rcb *RevisionCreateBulk) ExecX(ctx context.Context) {
if err := rcb.Exec(ctx); err != nil {
panic(err)
}
}
// OnConflict allows configuring the `ON CONFLICT` / `ON DUPLICATE KEY` clause
// of the `INSERT` statement. For example:
//
// client.Revision.CreateBulk(builders...).
// OnConflict(
// // Update the row with the new values
// // the was proposed for insertion.
// sql.ResolveWithNewValues(),
// ).
// // Override some of the fields with custom
// // update values.
// Update(func(u *ent.RevisionUpsert) {
// SetDescription(v+v).
// }).
// Exec(ctx)
func (rcb *RevisionCreateBulk) OnConflict(opts ...sql.ConflictOption) *RevisionUpsertBulk {
rcb.conflict = opts
return &RevisionUpsertBulk{
create: rcb,
}
}
// OnConflictColumns calls `OnConflict` and configures the columns
// as conflict target. Using this option is equivalent to using:
//
// client.Revision.Create().
// OnConflict(sql.ConflictColumns(columns...)).
// Exec(ctx)
func (rcb *RevisionCreateBulk) OnConflictColumns(columns ...string) *RevisionUpsertBulk {
rcb.conflict = append(rcb.conflict, sql.ConflictColumns(columns...))
return &RevisionUpsertBulk{
create: rcb,
}
}
// RevisionUpsertBulk is the builder for "upsert"-ing
// a bulk of Revision nodes.
type RevisionUpsertBulk struct {
create *RevisionCreateBulk
}
// UpdateNewValues updates the mutable fields using the new values that
// were set on create. Using this option is equivalent to using:
//
// client.Revision.Create().
// OnConflict(
// sql.ResolveWithNewValues(),
// sql.ResolveWith(func(u *sql.UpdateSet) {
// u.SetIgnore(revision.FieldID)
// }),
// ).
// Exec(ctx)
func (u *RevisionUpsertBulk) UpdateNewValues() *RevisionUpsertBulk {
u.create.conflict = append(u.create.conflict, sql.ResolveWithNewValues())
u.create.conflict = append(u.create.conflict, sql.ResolveWith(func(s *sql.UpdateSet) {
for _, b := range u.create.builders {
if _, exists := b.mutation.ID(); exists {
s.SetIgnore(revision.FieldID)
return
}
if _, exists := b.mutation.Description(); exists {
s.SetIgnore(revision.FieldDescription)
}
if _, exists := b.mutation.ExecutedAt(); exists {
s.SetIgnore(revision.FieldExecutedAt)
}
}
}))
return u
}
// Ignore sets each column to itself in case of conflict.
// Using this option is equivalent to using:
//
// client.Revision.Create().
// OnConflict(sql.ResolveWithIgnore()).
// Exec(ctx)
func (u *RevisionUpsertBulk) Ignore() *RevisionUpsertBulk {
u.create.conflict = append(u.create.conflict, sql.ResolveWithIgnore())
return u
}
// DoNothing configures the conflict_action to `DO NOTHING`.
// Supported only by SQLite and PostgreSQL.
func (u *RevisionUpsertBulk) DoNothing() *RevisionUpsertBulk {
u.create.conflict = append(u.create.conflict, sql.DoNothing())
return u
}
// Update allows overriding fields `UPDATE` values. See the RevisionCreateBulk.OnConflict
// documentation for more info.
func (u *RevisionUpsertBulk) Update(set func(*RevisionUpsert)) *RevisionUpsertBulk {
u.create.conflict = append(u.create.conflict, sql.ResolveWith(func(update *sql.UpdateSet) {
set(&RevisionUpsert{UpdateSet: update})
}))
return u
}
// SetDescription sets the "description" field.
func (u *RevisionUpsertBulk) SetDescription(v string) *RevisionUpsertBulk {
return u.Update(func(s *RevisionUpsert) {
s.SetDescription(v)
})
}
// UpdateDescription sets the "description" field to the value that was provided on create.
func (u *RevisionUpsertBulk) UpdateDescription() *RevisionUpsertBulk {
return u.Update(func(s *RevisionUpsert) {
s.UpdateDescription()
})
}
// SetType sets the "type" field.
func (u *RevisionUpsertBulk) SetType(v migrate.RevisionType) *RevisionUpsertBulk {
return u.Update(func(s *RevisionUpsert) {
s.SetType(v)
})
}
// AddType adds v to the "type" field.
func (u *RevisionUpsertBulk) AddType(v migrate.RevisionType) *RevisionUpsertBulk {
return u.Update(func(s *RevisionUpsert) {
s.AddType(v)
})
}
// UpdateType sets the "type" field to the value that was provided on create.
func (u *RevisionUpsertBulk) UpdateType() *RevisionUpsertBulk {
return u.Update(func(s *RevisionUpsert) {
s.UpdateType()
})
}
// SetApplied sets the "applied" field.
func (u *RevisionUpsertBulk) SetApplied(v int) *RevisionUpsertBulk {
return u.Update(func(s *RevisionUpsert) {
s.SetApplied(v)
})
}
// AddApplied adds v to the "applied" field.
func (u *RevisionUpsertBulk) AddApplied(v int) *RevisionUpsertBulk {
return u.Update(func(s *RevisionUpsert) {
s.AddApplied(v)
})
}
// UpdateApplied sets the "applied" field to the value that was provided on create.
func (u *RevisionUpsertBulk) UpdateApplied() *RevisionUpsertBulk {
return u.Update(func(s *RevisionUpsert) {
s.UpdateApplied()
})
}
// SetTotal sets the "total" field.
func (u *RevisionUpsertBulk) SetTotal(v int) *RevisionUpsertBulk {
return u.Update(func(s *RevisionUpsert) {
s.SetTotal(v)
})
}
// AddTotal adds v to the "total" field.
func (u *RevisionUpsertBulk) AddTotal(v int) *RevisionUpsertBulk {
return u.Update(func(s *RevisionUpsert) {
s.AddTotal(v)
})
}
// UpdateTotal sets the "total" field to the value that was provided on create.
func (u *RevisionUpsertBulk) UpdateTotal() *RevisionUpsertBulk {
return u.Update(func(s *RevisionUpsert) {
s.UpdateTotal()
})
}
// SetExecutedAt sets the "executed_at" field.
func (u *RevisionUpsertBulk) SetExecutedAt(v time.Time) *RevisionUpsertBulk {
return u.Update(func(s *RevisionUpsert) {
s.SetExecutedAt(v)
})
}
// UpdateExecutedAt sets the "executed_at" field to the value that was provided on create.
func (u *RevisionUpsertBulk) UpdateExecutedAt() *RevisionUpsertBulk {
return u.Update(func(s *RevisionUpsert) {
s.UpdateExecutedAt()
})
}
// SetExecutionTime sets the "execution_time" field.
func (u *RevisionUpsertBulk) SetExecutionTime(v time.Duration) *RevisionUpsertBulk {
return u.Update(func(s *RevisionUpsert) {
s.SetExecutionTime(v)
})
}
// AddExecutionTime adds v to the "execution_time" field.
func (u *RevisionUpsertBulk) AddExecutionTime(v time.Duration) *RevisionUpsertBulk {
return u.Update(func(s *RevisionUpsert) {
s.AddExecutionTime(v)
})
}
// UpdateExecutionTime sets the "execution_time" field to the value that was provided on create.
func (u *RevisionUpsertBulk) UpdateExecutionTime() *RevisionUpsertBulk {
return u.Update(func(s *RevisionUpsert) {
s.UpdateExecutionTime()
})
}
// SetError sets the "error" field.
func (u *RevisionUpsertBulk) SetError(v string) *RevisionUpsertBulk {
return u.Update(func(s *RevisionUpsert) {
s.SetError(v)
})
}
// UpdateError sets the "error" field to the value that was provided on create.
func (u *RevisionUpsertBulk) UpdateError() *RevisionUpsertBulk {
return u.Update(func(s *RevisionUpsert) {
s.UpdateError()
})
}
// ClearError clears the value of the "error" field.
func (u *RevisionUpsertBulk) ClearError() *RevisionUpsertBulk {
return u.Update(func(s *RevisionUpsert) {
s.ClearError()
})
}
// SetHash sets the "hash" field.
func (u *RevisionUpsertBulk) SetHash(v string) *RevisionUpsertBulk {
return u.Update(func(s *RevisionUpsert) {
s.SetHash(v)
})
}
// UpdateHash sets the "hash" field to the value that was provided on create.
func (u *RevisionUpsertBulk) UpdateHash() *RevisionUpsertBulk {
return u.Update(func(s *RevisionUpsert) {
s.UpdateHash()
})
}
// SetPartialHashes sets the "partial_hashes" field.
func (u *RevisionUpsertBulk) SetPartialHashes(v []string) *RevisionUpsertBulk {
return u.Update(func(s *RevisionUpsert) {
s.SetPartialHashes(v)
})
}
// UpdatePartialHashes sets the "partial_hashes" field to the value that was provided on create.
func (u *RevisionUpsertBulk) UpdatePartialHashes() *RevisionUpsertBulk {
return u.Update(func(s *RevisionUpsert) {
s.UpdatePartialHashes()
})
}
// ClearPartialHashes clears the value of the "partial_hashes" field.
func (u *RevisionUpsertBulk) ClearPartialHashes() *RevisionUpsertBulk {
return u.Update(func(s *RevisionUpsert) {
s.ClearPartialHashes()
})
}
// SetOperatorVersion sets the "operator_version" field.
func (u *RevisionUpsertBulk) SetOperatorVersion(v string) *RevisionUpsertBulk {
return u.Update(func(s *RevisionUpsert) {
s.SetOperatorVersion(v)
})
}
// UpdateOperatorVersion sets the "operator_version" field to the value that was provided on create.
func (u *RevisionUpsertBulk) UpdateOperatorVersion() *RevisionUpsertBulk {
return u.Update(func(s *RevisionUpsert) {
s.UpdateOperatorVersion()
})
}
// Exec executes the query.
func (u *RevisionUpsertBulk) Exec(ctx context.Context) error {
for i, b := range u.create.builders {
if len(b.conflict) != 0 {
return fmt.Errorf("ent: OnConflict was set for builder %d. Set it on the RevisionCreateBulk instead", i)
}
}
if len(u.create.conflict) == 0 {
return errors.New("ent: missing options for RevisionCreateBulk.OnConflict")
}
return u.create.Exec(ctx)
}
// ExecX is like Exec, but panics if an error occurs.
func (u *RevisionUpsertBulk) ExecX(ctx context.Context) {
if err := u.create.Exec(ctx); err != nil {
panic(err)
}
}
atlas-0.7.2/cmd/atlas/internal/migrate/ent/revision_delete.go 0000664 0000000 0000000 00000006147 14314555116 0024251 0 ustar 00root root 0000000 0000000 // Copyright 2021-present The Atlas Authors. All rights reserved.
// This source code is licensed under the Apache 2.0 license found
// in the LICENSE file in the root directory of this source tree.
// Code generated by entc, DO NOT EDIT.
package ent
import (
"context"
"fmt"
"ariga.io/atlas/cmd/atlas/internal/migrate/ent/internal"
"ariga.io/atlas/cmd/atlas/internal/migrate/ent/predicate"
"ariga.io/atlas/cmd/atlas/internal/migrate/ent/revision"
"entgo.io/ent/dialect/sql"
"entgo.io/ent/dialect/sql/sqlgraph"
"entgo.io/ent/schema/field"
)
// RevisionDelete is the builder for deleting a Revision entity.
type RevisionDelete struct {
config
hooks []Hook
mutation *RevisionMutation
}
// Where appends a list predicates to the RevisionDelete builder.
func (rd *RevisionDelete) Where(ps ...predicate.Revision) *RevisionDelete {
rd.mutation.Where(ps...)
return rd
}
// Exec executes the deletion query and returns how many vertices were deleted.
func (rd *RevisionDelete) Exec(ctx context.Context) (int, error) {
var (
err error
affected int
)
if len(rd.hooks) == 0 {
affected, err = rd.sqlExec(ctx)
} else {
var mut Mutator = MutateFunc(func(ctx context.Context, m Mutation) (Value, error) {
mutation, ok := m.(*RevisionMutation)
if !ok {
return nil, fmt.Errorf("unexpected mutation type %T", m)
}
rd.mutation = mutation
affected, err = rd.sqlExec(ctx)
mutation.done = true
return affected, err
})
for i := len(rd.hooks) - 1; i >= 0; i-- {
if rd.hooks[i] == nil {
return 0, fmt.Errorf("ent: uninitialized hook (forgotten import ent/runtime?)")
}
mut = rd.hooks[i](mut)
}
if _, err := mut.Mutate(ctx, rd.mutation); err != nil {
return 0, err
}
}
return affected, err
}
// ExecX is like Exec, but panics if an error occurs.
func (rd *RevisionDelete) ExecX(ctx context.Context) int {
n, err := rd.Exec(ctx)
if err != nil {
panic(err)
}
return n
}
func (rd *RevisionDelete) sqlExec(ctx context.Context) (int, error) {
_spec := &sqlgraph.DeleteSpec{
Node: &sqlgraph.NodeSpec{
Table: revision.Table,
ID: &sqlgraph.FieldSpec{
Type: field.TypeString,
Column: revision.FieldID,
},
},
}
_spec.Node.Schema = rd.schemaConfig.Revision
ctx = internal.NewSchemaConfigContext(ctx, rd.schemaConfig)
if ps := rd.mutation.predicates; len(ps) > 0 {
_spec.Predicate = func(selector *sql.Selector) {
for i := range ps {
ps[i](selector)
}
}
}
affected, err := sqlgraph.DeleteNodes(ctx, rd.driver, _spec)
if err != nil && sqlgraph.IsConstraintError(err) {
err = &ConstraintError{msg: err.Error(), wrap: err}
}
return affected, err
}
// RevisionDeleteOne is the builder for deleting a single Revision entity.
type RevisionDeleteOne struct {
rd *RevisionDelete
}
// Exec executes the deletion query.
func (rdo *RevisionDeleteOne) Exec(ctx context.Context) error {
n, err := rdo.rd.Exec(ctx)
switch {
case err != nil:
return err
case n == 0:
return &NotFoundError{revision.Label}
default:
return nil
}
}
// ExecX is like Exec, but panics if an error occurs.
func (rdo *RevisionDeleteOne) ExecX(ctx context.Context) {
rdo.rd.ExecX(ctx)
}
atlas-0.7.2/cmd/atlas/internal/migrate/ent/revision_query.go 0000664 0000000 0000000 00000034414 14314555116 0024152 0 ustar 00root root 0000000 0000000 // Copyright 2021-present The Atlas Authors. All rights reserved.
// This source code is licensed under the Apache 2.0 license found
// in the LICENSE file in the root directory of this source tree.
// Code generated by entc, DO NOT EDIT.
package ent
import (
"context"
"fmt"
"math"
"ariga.io/atlas/cmd/atlas/internal/migrate/ent/internal"
"ariga.io/atlas/cmd/atlas/internal/migrate/ent/predicate"
"ariga.io/atlas/cmd/atlas/internal/migrate/ent/revision"
"entgo.io/ent/dialect/sql"
"entgo.io/ent/dialect/sql/sqlgraph"
"entgo.io/ent/schema/field"
)
// RevisionQuery is the builder for querying Revision entities.
type RevisionQuery struct {
config
limit *int
offset *int
unique *bool
order []OrderFunc
fields []string
predicates []predicate.Revision
// intermediate query (i.e. traversal path).
sql *sql.Selector
path func(context.Context) (*sql.Selector, error)
}
// Where adds a new predicate for the RevisionQuery builder.
func (rq *RevisionQuery) Where(ps ...predicate.Revision) *RevisionQuery {
rq.predicates = append(rq.predicates, ps...)
return rq
}
// Limit adds a limit step to the query.
func (rq *RevisionQuery) Limit(limit int) *RevisionQuery {
rq.limit = &limit
return rq
}
// Offset adds an offset step to the query.
func (rq *RevisionQuery) Offset(offset int) *RevisionQuery {
rq.offset = &offset
return rq
}
// Unique configures the query builder to filter duplicate records on query.
// By default, unique is set to true, and can be disabled using this method.
func (rq *RevisionQuery) Unique(unique bool) *RevisionQuery {
rq.unique = &unique
return rq
}
// Order adds an order step to the query.
func (rq *RevisionQuery) Order(o ...OrderFunc) *RevisionQuery {
rq.order = append(rq.order, o...)
return rq
}
// First returns the first Revision entity from the query.
// Returns a *NotFoundError when no Revision was found.
func (rq *RevisionQuery) First(ctx context.Context) (*Revision, error) {
nodes, err := rq.Limit(1).All(ctx)
if err != nil {
return nil, err
}
if len(nodes) == 0 {
return nil, &NotFoundError{revision.Label}
}
return nodes[0], nil
}
// FirstX is like First, but panics if an error occurs.
func (rq *RevisionQuery) FirstX(ctx context.Context) *Revision {
node, err := rq.First(ctx)
if err != nil && !IsNotFound(err) {
panic(err)
}
return node
}
// FirstID returns the first Revision ID from the query.
// Returns a *NotFoundError when no Revision ID was found.
func (rq *RevisionQuery) FirstID(ctx context.Context) (id string, err error) {
var ids []string
if ids, err = rq.Limit(1).IDs(ctx); err != nil {
return
}
if len(ids) == 0 {
err = &NotFoundError{revision.Label}
return
}
return ids[0], nil
}
// FirstIDX is like FirstID, but panics if an error occurs.
func (rq *RevisionQuery) FirstIDX(ctx context.Context) string {
id, err := rq.FirstID(ctx)
if err != nil && !IsNotFound(err) {
panic(err)
}
return id
}
// Only returns a single Revision entity found by the query, ensuring it only returns one.
// Returns a *NotSingularError when more than one Revision entity is found.
// Returns a *NotFoundError when no Revision entities are found.
func (rq *RevisionQuery) Only(ctx context.Context) (*Revision, error) {
nodes, err := rq.Limit(2).All(ctx)
if err != nil {
return nil, err
}
switch len(nodes) {
case 1:
return nodes[0], nil
case 0:
return nil, &NotFoundError{revision.Label}
default:
return nil, &NotSingularError{revision.Label}
}
}
// OnlyX is like Only, but panics if an error occurs.
func (rq *RevisionQuery) OnlyX(ctx context.Context) *Revision {
node, err := rq.Only(ctx)
if err != nil {
panic(err)
}
return node
}
// OnlyID is like Only, but returns the only Revision ID in the query.
// Returns a *NotSingularError when more than one Revision ID is found.
// Returns a *NotFoundError when no entities are found.
func (rq *RevisionQuery) OnlyID(ctx context.Context) (id string, err error) {
var ids []string
if ids, err = rq.Limit(2).IDs(ctx); err != nil {
return
}
switch len(ids) {
case 1:
id = ids[0]
case 0:
err = &NotFoundError{revision.Label}
default:
err = &NotSingularError{revision.Label}
}
return
}
// OnlyIDX is like OnlyID, but panics if an error occurs.
func (rq *RevisionQuery) OnlyIDX(ctx context.Context) string {
id, err := rq.OnlyID(ctx)
if err != nil {
panic(err)
}
return id
}
// All executes the query and returns a list of Revisions.
func (rq *RevisionQuery) All(ctx context.Context) ([]*Revision, error) {
if err := rq.prepareQuery(ctx); err != nil {
return nil, err
}
return rq.sqlAll(ctx)
}
// AllX is like All, but panics if an error occurs.
func (rq *RevisionQuery) AllX(ctx context.Context) []*Revision {
nodes, err := rq.All(ctx)
if err != nil {
panic(err)
}
return nodes
}
// IDs executes the query and returns a list of Revision IDs.
func (rq *RevisionQuery) IDs(ctx context.Context) ([]string, error) {
var ids []string
if err := rq.Select(revision.FieldID).Scan(ctx, &ids); err != nil {
return nil, err
}
return ids, nil
}
// IDsX is like IDs, but panics if an error occurs.
func (rq *RevisionQuery) IDsX(ctx context.Context) []string {
ids, err := rq.IDs(ctx)
if err != nil {
panic(err)
}
return ids
}
// Count returns the count of the given query.
func (rq *RevisionQuery) Count(ctx context.Context) (int, error) {
if err := rq.prepareQuery(ctx); err != nil {
return 0, err
}
return rq.sqlCount(ctx)
}
// CountX is like Count, but panics if an error occurs.
func (rq *RevisionQuery) CountX(ctx context.Context) int {
count, err := rq.Count(ctx)
if err != nil {
panic(err)
}
return count
}
// Exist returns true if the query has elements in the graph.
func (rq *RevisionQuery) Exist(ctx context.Context) (bool, error) {
if err := rq.prepareQuery(ctx); err != nil {
return false, err
}
return rq.sqlExist(ctx)
}
// ExistX is like Exist, but panics if an error occurs.
func (rq *RevisionQuery) ExistX(ctx context.Context) bool {
exist, err := rq.Exist(ctx)
if err != nil {
panic(err)
}
return exist
}
// Clone returns a duplicate of the RevisionQuery builder, including all associated steps. It can be
// used to prepare common query builders and use them differently after the clone is made.
func (rq *RevisionQuery) Clone() *RevisionQuery {
if rq == nil {
return nil
}
return &RevisionQuery{
config: rq.config,
limit: rq.limit,
offset: rq.offset,
order: append([]OrderFunc{}, rq.order...),
predicates: append([]predicate.Revision{}, rq.predicates...),
// clone intermediate query.
sql: rq.sql.Clone(),
path: rq.path,
unique: rq.unique,
}
}
// GroupBy is used to group vertices by one or more fields/columns.
// It is often used with aggregate functions, like: count, max, mean, min, sum.
//
// Example:
//
// var v []struct {
// Description string `json:"description,omitempty"`
// Count int `json:"count,omitempty"`
// }
//
// client.Revision.Query().
// GroupBy(revision.FieldDescription).
// Aggregate(ent.Count()).
// Scan(ctx, &v)
func (rq *RevisionQuery) GroupBy(field string, fields ...string) *RevisionGroupBy {
grbuild := &RevisionGroupBy{config: rq.config}
grbuild.fields = append([]string{field}, fields...)
grbuild.path = func(ctx context.Context) (prev *sql.Selector, err error) {
if err := rq.prepareQuery(ctx); err != nil {
return nil, err
}
return rq.sqlQuery(ctx), nil
}
grbuild.label = revision.Label
grbuild.flds, grbuild.scan = &grbuild.fields, grbuild.Scan
return grbuild
}
// Select allows the selection one or more fields/columns for the given query,
// instead of selecting all fields in the entity.
//
// Example:
//
// var v []struct {
// Description string `json:"description,omitempty"`
// }
//
// client.Revision.Query().
// Select(revision.FieldDescription).
// Scan(ctx, &v)
func (rq *RevisionQuery) Select(fields ...string) *RevisionSelect {
rq.fields = append(rq.fields, fields...)
selbuild := &RevisionSelect{RevisionQuery: rq}
selbuild.label = revision.Label
selbuild.flds, selbuild.scan = &rq.fields, selbuild.Scan
return selbuild
}
func (rq *RevisionQuery) prepareQuery(ctx context.Context) error {
for _, f := range rq.fields {
if !revision.ValidColumn(f) {
return &ValidationError{Name: f, err: fmt.Errorf("ent: invalid field %q for query", f)}
}
}
if rq.path != nil {
prev, err := rq.path(ctx)
if err != nil {
return err
}
rq.sql = prev
}
return nil
}
func (rq *RevisionQuery) sqlAll(ctx context.Context, hooks ...queryHook) ([]*Revision, error) {
var (
nodes = []*Revision{}
_spec = rq.querySpec()
)
_spec.ScanValues = func(columns []string) ([]interface{}, error) {
return (*Revision).scanValues(nil, columns)
}
_spec.Assign = func(columns []string, values []interface{}) error {
node := &Revision{config: rq.config}
nodes = append(nodes, node)
return node.assignValues(columns, values)
}
_spec.Node.Schema = rq.schemaConfig.Revision
ctx = internal.NewSchemaConfigContext(ctx, rq.schemaConfig)
for i := range hooks {
hooks[i](ctx, _spec)
}
if err := sqlgraph.QueryNodes(ctx, rq.driver, _spec); err != nil {
return nil, err
}
if len(nodes) == 0 {
return nodes, nil
}
return nodes, nil
}
func (rq *RevisionQuery) sqlCount(ctx context.Context) (int, error) {
_spec := rq.querySpec()
_spec.Node.Schema = rq.schemaConfig.Revision
ctx = internal.NewSchemaConfigContext(ctx, rq.schemaConfig)
_spec.Node.Columns = rq.fields
if len(rq.fields) > 0 {
_spec.Unique = rq.unique != nil && *rq.unique
}
return sqlgraph.CountNodes(ctx, rq.driver, _spec)
}
func (rq *RevisionQuery) sqlExist(ctx context.Context) (bool, error) {
n, err := rq.sqlCount(ctx)
if err != nil {
return false, fmt.Errorf("ent: check existence: %w", err)
}
return n > 0, nil
}
func (rq *RevisionQuery) querySpec() *sqlgraph.QuerySpec {
_spec := &sqlgraph.QuerySpec{
Node: &sqlgraph.NodeSpec{
Table: revision.Table,
Columns: revision.Columns,
ID: &sqlgraph.FieldSpec{
Type: field.TypeString,
Column: revision.FieldID,
},
},
From: rq.sql,
Unique: true,
}
if unique := rq.unique; unique != nil {
_spec.Unique = *unique
}
if fields := rq.fields; len(fields) > 0 {
_spec.Node.Columns = make([]string, 0, len(fields))
_spec.Node.Columns = append(_spec.Node.Columns, revision.FieldID)
for i := range fields {
if fields[i] != revision.FieldID {
_spec.Node.Columns = append(_spec.Node.Columns, fields[i])
}
}
}
if ps := rq.predicates; len(ps) > 0 {
_spec.Predicate = func(selector *sql.Selector) {
for i := range ps {
ps[i](selector)
}
}
}
if limit := rq.limit; limit != nil {
_spec.Limit = *limit
}
if offset := rq.offset; offset != nil {
_spec.Offset = *offset
}
if ps := rq.order; len(ps) > 0 {
_spec.Order = func(selector *sql.Selector) {
for i := range ps {
ps[i](selector)
}
}
}
return _spec
}
func (rq *RevisionQuery) sqlQuery(ctx context.Context) *sql.Selector {
builder := sql.Dialect(rq.driver.Dialect())
t1 := builder.Table(revision.Table)
columns := rq.fields
if len(columns) == 0 {
columns = revision.Columns
}
selector := builder.Select(t1.Columns(columns...)...).From(t1)
if rq.sql != nil {
selector = rq.sql
selector.Select(selector.Columns(columns...)...)
}
if rq.unique != nil && *rq.unique {
selector.Distinct()
}
t1.Schema(rq.schemaConfig.Revision)
ctx = internal.NewSchemaConfigContext(ctx, rq.schemaConfig)
selector.WithContext(ctx)
for _, p := range rq.predicates {
p(selector)
}
for _, p := range rq.order {
p(selector)
}
if offset := rq.offset; offset != nil {
// limit is mandatory for offset clause. We start
// with default value, and override it below if needed.
selector.Offset(*offset).Limit(math.MaxInt32)
}
if limit := rq.limit; limit != nil {
selector.Limit(*limit)
}
return selector
}
// RevisionGroupBy is the group-by builder for Revision entities.
type RevisionGroupBy struct {
config
selector
fields []string
fns []AggregateFunc
// intermediate query (i.e. traversal path).
sql *sql.Selector
path func(context.Context) (*sql.Selector, error)
}
// Aggregate adds the given aggregation functions to the group-by query.
func (rgb *RevisionGroupBy) Aggregate(fns ...AggregateFunc) *RevisionGroupBy {
rgb.fns = append(rgb.fns, fns...)
return rgb
}
// Scan applies the group-by query and scans the result into the given value.
func (rgb *RevisionGroupBy) Scan(ctx context.Context, v interface{}) error {
query, err := rgb.path(ctx)
if err != nil {
return err
}
rgb.sql = query
return rgb.sqlScan(ctx, v)
}
func (rgb *RevisionGroupBy) sqlScan(ctx context.Context, v interface{}) error {
for _, f := range rgb.fields {
if !revision.ValidColumn(f) {
return &ValidationError{Name: f, err: fmt.Errorf("invalid field %q for group-by", f)}
}
}
selector := rgb.sqlQuery()
if err := selector.Err(); err != nil {
return err
}
rows := &sql.Rows{}
query, args := selector.Query()
if err := rgb.driver.Query(ctx, query, args, rows); err != nil {
return err
}
defer rows.Close()
return sql.ScanSlice(rows, v)
}
func (rgb *RevisionGroupBy) sqlQuery() *sql.Selector {
selector := rgb.sql.Select()
aggregation := make([]string, 0, len(rgb.fns))
for _, fn := range rgb.fns {
aggregation = append(aggregation, fn(selector))
}
// If no columns were selected in a custom aggregation function, the default
// selection is the fields used for "group-by", and the aggregation functions.
if len(selector.SelectedColumns()) == 0 {
columns := make([]string, 0, len(rgb.fields)+len(rgb.fns))
for _, f := range rgb.fields {
columns = append(columns, selector.C(f))
}
columns = append(columns, aggregation...)
selector.Select(columns...)
}
return selector.GroupBy(selector.Columns(rgb.fields...)...)
}
// RevisionSelect is the builder for selecting fields of Revision entities.
type RevisionSelect struct {
*RevisionQuery
selector
// intermediate query (i.e. traversal path).
sql *sql.Selector
}
// Scan applies the selector query and scans the result into the given value.
func (rs *RevisionSelect) Scan(ctx context.Context, v interface{}) error {
if err := rs.prepareQuery(ctx); err != nil {
return err
}
rs.sql = rs.RevisionQuery.sqlQuery(ctx)
return rs.sqlScan(ctx, v)
}
func (rs *RevisionSelect) sqlScan(ctx context.Context, v interface{}) error {
rows := &sql.Rows{}
query, args := rs.sql.Query()
if err := rs.driver.Query(ctx, query, args, rows); err != nil {
return err
}
defer rows.Close()
return sql.ScanSlice(rows, v)
}
atlas-0.7.2/cmd/atlas/internal/migrate/ent/revision_update.go 0000664 0000000 0000000 00000047713 14314555116 0024275 0 ustar 00root root 0000000 0000000 // Copyright 2021-present The Atlas Authors. All rights reserved.
// This source code is licensed under the Apache 2.0 license found
// in the LICENSE file in the root directory of this source tree.
// Code generated by entc, DO NOT EDIT.
package ent
import (
"context"
"errors"
"fmt"
"time"
"ariga.io/atlas/cmd/atlas/internal/migrate/ent/internal"
"ariga.io/atlas/cmd/atlas/internal/migrate/ent/predicate"
"ariga.io/atlas/cmd/atlas/internal/migrate/ent/revision"
"ariga.io/atlas/sql/migrate"
"entgo.io/ent/dialect/sql"
"entgo.io/ent/dialect/sql/sqlgraph"
"entgo.io/ent/schema/field"
)
// RevisionUpdate is the builder for updating Revision entities.
type RevisionUpdate struct {
config
hooks []Hook
mutation *RevisionMutation
}
// Where appends a list predicates to the RevisionUpdate builder.
func (ru *RevisionUpdate) Where(ps ...predicate.Revision) *RevisionUpdate {
ru.mutation.Where(ps...)
return ru
}
// SetType sets the "type" field.
func (ru *RevisionUpdate) SetType(mt migrate.RevisionType) *RevisionUpdate {
ru.mutation.ResetType()
ru.mutation.SetType(mt)
return ru
}
// SetNillableType sets the "type" field if the given value is not nil.
func (ru *RevisionUpdate) SetNillableType(mt *migrate.RevisionType) *RevisionUpdate {
if mt != nil {
ru.SetType(*mt)
}
return ru
}
// AddType adds mt to the "type" field.
func (ru *RevisionUpdate) AddType(mt migrate.RevisionType) *RevisionUpdate {
ru.mutation.AddType(mt)
return ru
}
// SetApplied sets the "applied" field.
func (ru *RevisionUpdate) SetApplied(i int) *RevisionUpdate {
ru.mutation.ResetApplied()
ru.mutation.SetApplied(i)
return ru
}
// SetNillableApplied sets the "applied" field if the given value is not nil.
func (ru *RevisionUpdate) SetNillableApplied(i *int) *RevisionUpdate {
if i != nil {
ru.SetApplied(*i)
}
return ru
}
// AddApplied adds i to the "applied" field.
func (ru *RevisionUpdate) AddApplied(i int) *RevisionUpdate {
ru.mutation.AddApplied(i)
return ru
}
// SetTotal sets the "total" field.
func (ru *RevisionUpdate) SetTotal(i int) *RevisionUpdate {
ru.mutation.ResetTotal()
ru.mutation.SetTotal(i)
return ru
}
// SetNillableTotal sets the "total" field if the given value is not nil.
func (ru *RevisionUpdate) SetNillableTotal(i *int) *RevisionUpdate {
if i != nil {
ru.SetTotal(*i)
}
return ru
}
// AddTotal adds i to the "total" field.
func (ru *RevisionUpdate) AddTotal(i int) *RevisionUpdate {
ru.mutation.AddTotal(i)
return ru
}
// SetExecutionTime sets the "execution_time" field.
func (ru *RevisionUpdate) SetExecutionTime(t time.Duration) *RevisionUpdate {
ru.mutation.ResetExecutionTime()
ru.mutation.SetExecutionTime(t)
return ru
}
// AddExecutionTime adds t to the "execution_time" field.
func (ru *RevisionUpdate) AddExecutionTime(t time.Duration) *RevisionUpdate {
ru.mutation.AddExecutionTime(t)
return ru
}
// SetError sets the "error" field.
func (ru *RevisionUpdate) SetError(s string) *RevisionUpdate {
ru.mutation.SetError(s)
return ru
}
// SetNillableError sets the "error" field if the given value is not nil.
func (ru *RevisionUpdate) SetNillableError(s *string) *RevisionUpdate {
if s != nil {
ru.SetError(*s)
}
return ru
}
// ClearError clears the value of the "error" field.
func (ru *RevisionUpdate) ClearError() *RevisionUpdate {
ru.mutation.ClearError()
return ru
}
// SetHash sets the "hash" field.
func (ru *RevisionUpdate) SetHash(s string) *RevisionUpdate {
ru.mutation.SetHash(s)
return ru
}
// SetPartialHashes sets the "partial_hashes" field.
func (ru *RevisionUpdate) SetPartialHashes(s []string) *RevisionUpdate {
ru.mutation.SetPartialHashes(s)
return ru
}
// ClearPartialHashes clears the value of the "partial_hashes" field.
func (ru *RevisionUpdate) ClearPartialHashes() *RevisionUpdate {
ru.mutation.ClearPartialHashes()
return ru
}
// SetOperatorVersion sets the "operator_version" field.
func (ru *RevisionUpdate) SetOperatorVersion(s string) *RevisionUpdate {
ru.mutation.SetOperatorVersion(s)
return ru
}
// Mutation returns the RevisionMutation object of the builder.
func (ru *RevisionUpdate) Mutation() *RevisionMutation {
return ru.mutation
}
// Save executes the query and returns the number of nodes affected by the update operation.
func (ru *RevisionUpdate) Save(ctx context.Context) (int, error) {
var (
err error
affected int
)
if len(ru.hooks) == 0 {
if err = ru.check(); err != nil {
return 0, err
}
affected, err = ru.sqlSave(ctx)
} else {
var mut Mutator = MutateFunc(func(ctx context.Context, m Mutation) (Value, error) {
mutation, ok := m.(*RevisionMutation)
if !ok {
return nil, fmt.Errorf("unexpected mutation type %T", m)
}
if err = ru.check(); err != nil {
return 0, err
}
ru.mutation = mutation
affected, err = ru.sqlSave(ctx)
mutation.done = true
return affected, err
})
for i := len(ru.hooks) - 1; i >= 0; i-- {
if ru.hooks[i] == nil {
return 0, fmt.Errorf("ent: uninitialized hook (forgotten import ent/runtime?)")
}
mut = ru.hooks[i](mut)
}
if _, err := mut.Mutate(ctx, ru.mutation); err != nil {
return 0, err
}
}
return affected, err
}
// SaveX is like Save, but panics if an error occurs.
func (ru *RevisionUpdate) SaveX(ctx context.Context) int {
affected, err := ru.Save(ctx)
if err != nil {
panic(err)
}
return affected
}
// Exec executes the query.
func (ru *RevisionUpdate) Exec(ctx context.Context) error {
_, err := ru.Save(ctx)
return err
}
// ExecX is like Exec, but panics if an error occurs.
func (ru *RevisionUpdate) ExecX(ctx context.Context) {
if err := ru.Exec(ctx); err != nil {
panic(err)
}
}
// check runs all checks and user-defined validators on the builder.
func (ru *RevisionUpdate) check() error {
if v, ok := ru.mutation.Applied(); ok {
if err := revision.AppliedValidator(v); err != nil {
return &ValidationError{Name: "applied", err: fmt.Errorf(`ent: validator failed for field "Revision.applied": %w`, err)}
}
}
if v, ok := ru.mutation.Total(); ok {
if err := revision.TotalValidator(v); err != nil {
return &ValidationError{Name: "total", err: fmt.Errorf(`ent: validator failed for field "Revision.total": %w`, err)}
}
}
return nil
}
func (ru *RevisionUpdate) sqlSave(ctx context.Context) (n int, err error) {
_spec := &sqlgraph.UpdateSpec{
Node: &sqlgraph.NodeSpec{
Table: revision.Table,
Columns: revision.Columns,
ID: &sqlgraph.FieldSpec{
Type: field.TypeString,
Column: revision.FieldID,
},
},
}
if ps := ru.mutation.predicates; len(ps) > 0 {
_spec.Predicate = func(selector *sql.Selector) {
for i := range ps {
ps[i](selector)
}
}
}
if value, ok := ru.mutation.GetType(); ok {
_spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{
Type: field.TypeUint,
Value: value,
Column: revision.FieldType,
})
}
if value, ok := ru.mutation.AddedType(); ok {
_spec.Fields.Add = append(_spec.Fields.Add, &sqlgraph.FieldSpec{
Type: field.TypeUint,
Value: value,
Column: revision.FieldType,
})
}
if value, ok := ru.mutation.Applied(); ok {
_spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{
Type: field.TypeInt,
Value: value,
Column: revision.FieldApplied,
})
}
if value, ok := ru.mutation.AddedApplied(); ok {
_spec.Fields.Add = append(_spec.Fields.Add, &sqlgraph.FieldSpec{
Type: field.TypeInt,
Value: value,
Column: revision.FieldApplied,
})
}
if value, ok := ru.mutation.Total(); ok {
_spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{
Type: field.TypeInt,
Value: value,
Column: revision.FieldTotal,
})
}
if value, ok := ru.mutation.AddedTotal(); ok {
_spec.Fields.Add = append(_spec.Fields.Add, &sqlgraph.FieldSpec{
Type: field.TypeInt,
Value: value,
Column: revision.FieldTotal,
})
}
if value, ok := ru.mutation.ExecutionTime(); ok {
_spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{
Type: field.TypeInt64,
Value: value,
Column: revision.FieldExecutionTime,
})
}
if value, ok := ru.mutation.AddedExecutionTime(); ok {
_spec.Fields.Add = append(_spec.Fields.Add, &sqlgraph.FieldSpec{
Type: field.TypeInt64,
Value: value,
Column: revision.FieldExecutionTime,
})
}
if value, ok := ru.mutation.Error(); ok {
_spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{
Type: field.TypeString,
Value: value,
Column: revision.FieldError,
})
}
if ru.mutation.ErrorCleared() {
_spec.Fields.Clear = append(_spec.Fields.Clear, &sqlgraph.FieldSpec{
Type: field.TypeString,
Column: revision.FieldError,
})
}
if value, ok := ru.mutation.Hash(); ok {
_spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{
Type: field.TypeString,
Value: value,
Column: revision.FieldHash,
})
}
if value, ok := ru.mutation.PartialHashes(); ok {
_spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{
Type: field.TypeJSON,
Value: value,
Column: revision.FieldPartialHashes,
})
}
if ru.mutation.PartialHashesCleared() {
_spec.Fields.Clear = append(_spec.Fields.Clear, &sqlgraph.FieldSpec{
Type: field.TypeJSON,
Column: revision.FieldPartialHashes,
})
}
if value, ok := ru.mutation.OperatorVersion(); ok {
_spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{
Type: field.TypeString,
Value: value,
Column: revision.FieldOperatorVersion,
})
}
_spec.Node.Schema = ru.schemaConfig.Revision
ctx = internal.NewSchemaConfigContext(ctx, ru.schemaConfig)
if n, err = sqlgraph.UpdateNodes(ctx, ru.driver, _spec); err != nil {
if _, ok := err.(*sqlgraph.NotFoundError); ok {
err = &NotFoundError{revision.Label}
} else if sqlgraph.IsConstraintError(err) {
err = &ConstraintError{msg: err.Error(), wrap: err}
}
return 0, err
}
return n, nil
}
// RevisionUpdateOne is the builder for updating a single Revision entity.
type RevisionUpdateOne struct {
config
fields []string
hooks []Hook
mutation *RevisionMutation
}
// SetType sets the "type" field.
func (ruo *RevisionUpdateOne) SetType(mt migrate.RevisionType) *RevisionUpdateOne {
ruo.mutation.ResetType()
ruo.mutation.SetType(mt)
return ruo
}
// SetNillableType sets the "type" field if the given value is not nil.
func (ruo *RevisionUpdateOne) SetNillableType(mt *migrate.RevisionType) *RevisionUpdateOne {
if mt != nil {
ruo.SetType(*mt)
}
return ruo
}
// AddType adds mt to the "type" field.
func (ruo *RevisionUpdateOne) AddType(mt migrate.RevisionType) *RevisionUpdateOne {
ruo.mutation.AddType(mt)
return ruo
}
// SetApplied sets the "applied" field.
func (ruo *RevisionUpdateOne) SetApplied(i int) *RevisionUpdateOne {
ruo.mutation.ResetApplied()
ruo.mutation.SetApplied(i)
return ruo
}
// SetNillableApplied sets the "applied" field if the given value is not nil.
func (ruo *RevisionUpdateOne) SetNillableApplied(i *int) *RevisionUpdateOne {
if i != nil {
ruo.SetApplied(*i)
}
return ruo
}
// AddApplied adds i to the "applied" field.
func (ruo *RevisionUpdateOne) AddApplied(i int) *RevisionUpdateOne {
ruo.mutation.AddApplied(i)
return ruo
}
// SetTotal sets the "total" field.
func (ruo *RevisionUpdateOne) SetTotal(i int) *RevisionUpdateOne {
ruo.mutation.ResetTotal()
ruo.mutation.SetTotal(i)
return ruo
}
// SetNillableTotal sets the "total" field if the given value is not nil.
func (ruo *RevisionUpdateOne) SetNillableTotal(i *int) *RevisionUpdateOne {
if i != nil {
ruo.SetTotal(*i)
}
return ruo
}
// AddTotal adds i to the "total" field.
func (ruo *RevisionUpdateOne) AddTotal(i int) *RevisionUpdateOne {
ruo.mutation.AddTotal(i)
return ruo
}
// SetExecutionTime sets the "execution_time" field.
func (ruo *RevisionUpdateOne) SetExecutionTime(t time.Duration) *RevisionUpdateOne {
ruo.mutation.ResetExecutionTime()
ruo.mutation.SetExecutionTime(t)
return ruo
}
// AddExecutionTime adds t to the "execution_time" field.
func (ruo *RevisionUpdateOne) AddExecutionTime(t time.Duration) *RevisionUpdateOne {
ruo.mutation.AddExecutionTime(t)
return ruo
}
// SetError sets the "error" field.
func (ruo *RevisionUpdateOne) SetError(s string) *RevisionUpdateOne {
ruo.mutation.SetError(s)
return ruo
}
// SetNillableError sets the "error" field if the given value is not nil.
func (ruo *RevisionUpdateOne) SetNillableError(s *string) *RevisionUpdateOne {
if s != nil {
ruo.SetError(*s)
}
return ruo
}
// ClearError clears the value of the "error" field.
func (ruo *RevisionUpdateOne) ClearError() *RevisionUpdateOne {
ruo.mutation.ClearError()
return ruo
}
// SetHash sets the "hash" field.
func (ruo *RevisionUpdateOne) SetHash(s string) *RevisionUpdateOne {
ruo.mutation.SetHash(s)
return ruo
}
// SetPartialHashes sets the "partial_hashes" field.
func (ruo *RevisionUpdateOne) SetPartialHashes(s []string) *RevisionUpdateOne {
ruo.mutation.SetPartialHashes(s)
return ruo
}
// ClearPartialHashes clears the value of the "partial_hashes" field.
func (ruo *RevisionUpdateOne) ClearPartialHashes() *RevisionUpdateOne {
ruo.mutation.ClearPartialHashes()
return ruo
}
// SetOperatorVersion sets the "operator_version" field.
func (ruo *RevisionUpdateOne) SetOperatorVersion(s string) *RevisionUpdateOne {
ruo.mutation.SetOperatorVersion(s)
return ruo
}
// Mutation returns the RevisionMutation object of the builder.
func (ruo *RevisionUpdateOne) Mutation() *RevisionMutation {
return ruo.mutation
}
// Select allows selecting one or more fields (columns) of the returned entity.
// The default is selecting all fields defined in the entity schema.
func (ruo *RevisionUpdateOne) Select(field string, fields ...string) *RevisionUpdateOne {
ruo.fields = append([]string{field}, fields...)
return ruo
}
// Save executes the query and returns the updated Revision entity.
func (ruo *RevisionUpdateOne) Save(ctx context.Context) (*Revision, error) {
var (
err error
node *Revision
)
if len(ruo.hooks) == 0 {
if err = ruo.check(); err != nil {
return nil, err
}
node, err = ruo.sqlSave(ctx)
} else {
var mut Mutator = MutateFunc(func(ctx context.Context, m Mutation) (Value, error) {
mutation, ok := m.(*RevisionMutation)
if !ok {
return nil, fmt.Errorf("unexpected mutation type %T", m)
}
if err = ruo.check(); err != nil {
return nil, err
}
ruo.mutation = mutation
node, err = ruo.sqlSave(ctx)
mutation.done = true
return node, err
})
for i := len(ruo.hooks) - 1; i >= 0; i-- {
if ruo.hooks[i] == nil {
return nil, fmt.Errorf("ent: uninitialized hook (forgotten import ent/runtime?)")
}
mut = ruo.hooks[i](mut)
}
v, err := mut.Mutate(ctx, ruo.mutation)
if err != nil {
return nil, err
}
nv, ok := v.(*Revision)
if !ok {
return nil, fmt.Errorf("unexpected node type %T returned from RevisionMutation", v)
}
node = nv
}
return node, err
}
// SaveX is like Save, but panics if an error occurs.
func (ruo *RevisionUpdateOne) SaveX(ctx context.Context) *Revision {
node, err := ruo.Save(ctx)
if err != nil {
panic(err)
}
return node
}
// Exec executes the query on the entity.
func (ruo *RevisionUpdateOne) Exec(ctx context.Context) error {
_, err := ruo.Save(ctx)
return err
}
// ExecX is like Exec, but panics if an error occurs.
func (ruo *RevisionUpdateOne) ExecX(ctx context.Context) {
if err := ruo.Exec(ctx); err != nil {
panic(err)
}
}
// check runs all checks and user-defined validators on the builder.
func (ruo *RevisionUpdateOne) check() error {
if v, ok := ruo.mutation.Applied(); ok {
if err := revision.AppliedValidator(v); err != nil {
return &ValidationError{Name: "applied", err: fmt.Errorf(`ent: validator failed for field "Revision.applied": %w`, err)}
}
}
if v, ok := ruo.mutation.Total(); ok {
if err := revision.TotalValidator(v); err != nil {
return &ValidationError{Name: "total", err: fmt.Errorf(`ent: validator failed for field "Revision.total": %w`, err)}
}
}
return nil
}
func (ruo *RevisionUpdateOne) sqlSave(ctx context.Context) (_node *Revision, err error) {
_spec := &sqlgraph.UpdateSpec{
Node: &sqlgraph.NodeSpec{
Table: revision.Table,
Columns: revision.Columns,
ID: &sqlgraph.FieldSpec{
Type: field.TypeString,
Column: revision.FieldID,
},
},
}
id, ok := ruo.mutation.ID()
if !ok {
return nil, &ValidationError{Name: "id", err: errors.New(`ent: missing "Revision.id" for update`)}
}
_spec.Node.ID.Value = id
if fields := ruo.fields; len(fields) > 0 {
_spec.Node.Columns = make([]string, 0, len(fields))
_spec.Node.Columns = append(_spec.Node.Columns, revision.FieldID)
for _, f := range fields {
if !revision.ValidColumn(f) {
return nil, &ValidationError{Name: f, err: fmt.Errorf("ent: invalid field %q for query", f)}
}
if f != revision.FieldID {
_spec.Node.Columns = append(_spec.Node.Columns, f)
}
}
}
if ps := ruo.mutation.predicates; len(ps) > 0 {
_spec.Predicate = func(selector *sql.Selector) {
for i := range ps {
ps[i](selector)
}
}
}
if value, ok := ruo.mutation.GetType(); ok {
_spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{
Type: field.TypeUint,
Value: value,
Column: revision.FieldType,
})
}
if value, ok := ruo.mutation.AddedType(); ok {
_spec.Fields.Add = append(_spec.Fields.Add, &sqlgraph.FieldSpec{
Type: field.TypeUint,
Value: value,
Column: revision.FieldType,
})
}
if value, ok := ruo.mutation.Applied(); ok {
_spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{
Type: field.TypeInt,
Value: value,
Column: revision.FieldApplied,
})
}
if value, ok := ruo.mutation.AddedApplied(); ok {
_spec.Fields.Add = append(_spec.Fields.Add, &sqlgraph.FieldSpec{
Type: field.TypeInt,
Value: value,
Column: revision.FieldApplied,
})
}
if value, ok := ruo.mutation.Total(); ok {
_spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{
Type: field.TypeInt,
Value: value,
Column: revision.FieldTotal,
})
}
if value, ok := ruo.mutation.AddedTotal(); ok {
_spec.Fields.Add = append(_spec.Fields.Add, &sqlgraph.FieldSpec{
Type: field.TypeInt,
Value: value,
Column: revision.FieldTotal,
})
}
if value, ok := ruo.mutation.ExecutionTime(); ok {
_spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{
Type: field.TypeInt64,
Value: value,
Column: revision.FieldExecutionTime,
})
}
if value, ok := ruo.mutation.AddedExecutionTime(); ok {
_spec.Fields.Add = append(_spec.Fields.Add, &sqlgraph.FieldSpec{
Type: field.TypeInt64,
Value: value,
Column: revision.FieldExecutionTime,
})
}
if value, ok := ruo.mutation.Error(); ok {
_spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{
Type: field.TypeString,
Value: value,
Column: revision.FieldError,
})
}
if ruo.mutation.ErrorCleared() {
_spec.Fields.Clear = append(_spec.Fields.Clear, &sqlgraph.FieldSpec{
Type: field.TypeString,
Column: revision.FieldError,
})
}
if value, ok := ruo.mutation.Hash(); ok {
_spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{
Type: field.TypeString,
Value: value,
Column: revision.FieldHash,
})
}
if value, ok := ruo.mutation.PartialHashes(); ok {
_spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{
Type: field.TypeJSON,
Value: value,
Column: revision.FieldPartialHashes,
})
}
if ruo.mutation.PartialHashesCleared() {
_spec.Fields.Clear = append(_spec.Fields.Clear, &sqlgraph.FieldSpec{
Type: field.TypeJSON,
Column: revision.FieldPartialHashes,
})
}
if value, ok := ruo.mutation.OperatorVersion(); ok {
_spec.Fields.Set = append(_spec.Fields.Set, &sqlgraph.FieldSpec{
Type: field.TypeString,
Value: value,
Column: revision.FieldOperatorVersion,
})
}
_spec.Node.Schema = ruo.schemaConfig.Revision
ctx = internal.NewSchemaConfigContext(ctx, ruo.schemaConfig)
_node = &Revision{config: ruo.config}
_spec.Assign = _node.assignValues
_spec.ScanValues = _node.scanValues
if err = sqlgraph.UpdateNode(ctx, ruo.driver, _spec); err != nil {
if _, ok := err.(*sqlgraph.NotFoundError); ok {
err = &NotFoundError{revision.Label}
} else if sqlgraph.IsConstraintError(err) {
err = &ConstraintError{msg: err.Error(), wrap: err}
}
return nil, err
}
return _node, nil
}
atlas-0.7.2/cmd/atlas/internal/migrate/ent/runtime.go 0000664 0000000 0000000 00000003456 14314555116 0022554 0 ustar 00root root 0000000 0000000 // Copyright 2021-present The Atlas Authors. All rights reserved.
// This source code is licensed under the Apache 2.0 license found
// in the LICENSE file in the root directory of this source tree.
// Code generated by entc, DO NOT EDIT.
package ent
import (
"ariga.io/atlas/cmd/atlas/internal/migrate/ent/revision"
"ariga.io/atlas/cmd/atlas/internal/migrate/ent/schema"
"ariga.io/atlas/sql/migrate"
)
// The init function reads all schema descriptors with runtime code
// (default values, validators, hooks and policies) and stitches it
// to their package variables.
func init() {
revisionFields := schema.Revision{}.Fields()
_ = revisionFields
// revisionDescType is the schema descriptor for type field.
revisionDescType := revisionFields[2].Descriptor()
// revision.DefaultType holds the default value on creation for the type field.
revision.DefaultType = migrate.RevisionType(revisionDescType.Default.(uint))
// revisionDescApplied is the schema descriptor for applied field.
revisionDescApplied := revisionFields[3].Descriptor()
// revision.DefaultApplied holds the default value on creation for the applied field.
revision.DefaultApplied = revisionDescApplied.Default.(int)
// revision.AppliedValidator is a validator for the "applied" field. It is called by the builders before save.
revision.AppliedValidator = revisionDescApplied.Validators[0].(func(int) error)
// revisionDescTotal is the schema descriptor for total field.
revisionDescTotal := revisionFields[4].Descriptor()
// revision.DefaultTotal holds the default value on creation for the total field.
revision.DefaultTotal = revisionDescTotal.Default.(int)
// revision.TotalValidator is a validator for the "total" field. It is called by the builders before save.
revision.TotalValidator = revisionDescTotal.Validators[0].(func(int) error)
}
atlas-0.7.2/cmd/atlas/internal/migrate/ent/runtime/ 0000775 0000000 0000000 00000000000 14314555116 0022215 5 ustar 00root root 0000000 0000000 atlas-0.7.2/cmd/atlas/internal/migrate/ent/runtime/runtime.go 0000664 0000000 0000000 00000001040 14314555116 0024222 0 ustar 00root root 0000000 0000000 // Copyright 2021-present The Atlas Authors. All rights reserved.
// This source code is licensed under the Apache 2.0 license found
// in the LICENSE file in the root directory of this source tree.
// Code generated by entc, DO NOT EDIT.
package runtime
// The schema-stitching logic is generated in ariga.io/atlas/cmd/atlas/internal/migrate/ent/runtime.go
const (
Version = "v0.11.1" // Version of ent codegen.
Sum = "h1:im67R+2W3Nee2bNS2YnoYz8oAF0Qz4AOlIvKRIAEISY=" // Sum of ent codegen.
)
atlas-0.7.2/cmd/atlas/internal/migrate/ent/schema/ 0000775 0000000 0000000 00000000000 14314555116 0021772 5 ustar 00root root 0000000 0000000 atlas-0.7.2/cmd/atlas/internal/migrate/ent/schema/revision.go 0000664 0000000 0000000 00000002647 14314555116 0024170 0 ustar 00root root 0000000 0000000 // Copyright 2021-present The Atlas Authors. All rights reserved.
// This source code is licensed under the Apache 2.0 license found
// in the LICENSE file in the root directory of this source tree.
package schema
import (
"time"
"ariga.io/atlas/sql/migrate"
"entgo.io/ent"
"entgo.io/ent/dialect/entsql"
"entgo.io/ent/schema"
"entgo.io/ent/schema/field"
)
// DefaultRevisionSchema is the default schema for storing revisions table.
const DefaultRevisionSchema = "atlas_schema_revisions"
// Revision holds the schema definition for the Revision entity.
type Revision struct {
ent.Schema
}
// Fields of the Revision.
func (Revision) Fields() []ent.Field {
return []ent.Field{
field.String("id").
StorageKey("version").
Immutable(),
field.String("description").
Immutable(),
field.Uint("type").
GoType(migrate.RevisionType(0)).
Default(uint(migrate.RevisionTypeExecute)),
field.Int("applied").
NonNegative().
Default(0),
field.Int("total").
NonNegative().
Default(0),
field.Time("executed_at").
Immutable(),
field.Int64("execution_time").
GoType(time.Duration(0)),
field.Text("error").
Optional(),
field.String("hash"),
field.Strings("partial_hashes").
Optional(),
field.String("operator_version"),
}
}
// Annotations of the Revision.
func (Revision) Annotations() []schema.Annotation {
return []schema.Annotation{
entsql.Annotation{Table: DefaultRevisionSchema},
}
}
atlas-0.7.2/cmd/atlas/internal/migrate/ent/template/ 0000775 0000000 0000000 00000000000 14314555116 0022345 5 ustar 00root root 0000000 0000000 atlas-0.7.2/cmd/atlas/internal/migrate/ent/template/convert.tmpl 0000664 0000000 0000000 00000002220 14314555116 0024717 0 ustar 00root root 0000000 0000000 {{/* gotype: entgo.io/ent/entc/gen.Graph */}}
{{ define "convert" }}
{{ $pkg := base $.Config.Package }}
{{ template "header" $ }}
import "ariga.io/atlas/sql/migrate"
{{ range $n := $.Nodes }}
{{ if eq $n.Name "Revision" }}
{{ $builder := $n.CreateName }}
{{ $receiver := receiver $builder }}
// SetRevision takes the values for each field from the given migrate.Revision.
func ({{ $receiver }} *{{ $builder }}) SetRevision(rev *migrate.Revision) *{{ $builder }} {
{{ $receiver }}.SetID(rev.Version)
{{- range $f := $n.Fields }}
{{ $receiver }}.Set{{ $f.StructField }}(rev.{{ $f.StructField }})
{{- end }}
return {{ $receiver }}
}
// AtlasRevision returns an migrate.Revision from the current Revision.
func({{ $n.Receiver}} *Revision) AtlasRevision() *migrate.Revision {
return &migrate.Revision{
Version: r.ID,
{{- range $f := $n.Fields }}
{{ $f.StructField }}: r.{{ $f.StructField }},
{{- end }}
}
}
{{ end }}
{{ end }}
{{ end }}
atlas-0.7.2/cmd/atlas/internal/migrate/ent/tx.go 0000664 0000000 0000000 00000016330 14314555116 0021517 0 ustar 00root root 0000000 0000000 // Copyright 2021-present The Atlas Authors. All rights reserved.
// This source code is licensed under the Apache 2.0 license found
// in the LICENSE file in the root directory of this source tree.
// Code generated by entc, DO NOT EDIT.
package ent
import (
"context"
stdsql "database/sql"
"fmt"
"sync"
"entgo.io/ent/dialect"
)
// Tx is a transactional client that is created by calling Client.Tx().
type Tx struct {
config
// Revision is the client for interacting with the Revision builders.
Revision *RevisionClient
// lazily loaded.
client *Client
clientOnce sync.Once
// completion callbacks.
mu sync.Mutex
onCommit []CommitHook
onRollback []RollbackHook
// ctx lives for the life of the transaction. It is
// the same context used by the underlying connection.
ctx context.Context
}
type (
// Committer is the interface that wraps the Commit method.
Committer interface {
Commit(context.Context, *Tx) error
}
// The CommitFunc type is an adapter to allow the use of ordinary
// function as a Committer. If f is a function with the appropriate
// signature, CommitFunc(f) is a Committer that calls f.
CommitFunc func(context.Context, *Tx) error
// CommitHook defines the "commit middleware". A function that gets a Committer
// and returns a Committer. For example:
//
// hook := func(next ent.Committer) ent.Committer {
// return ent.CommitFunc(func(ctx context.Context, tx *ent.Tx) error {
// // Do some stuff before.
// if err := next.Commit(ctx, tx); err != nil {
// return err
// }
// // Do some stuff after.
// return nil
// })
// }
//
CommitHook func(Committer) Committer
)
// Commit calls f(ctx, m).
func (f CommitFunc) Commit(ctx context.Context, tx *Tx) error {
return f(ctx, tx)
}
// Commit commits the transaction.
func (tx *Tx) Commit() error {
txDriver := tx.config.driver.(*txDriver)
var fn Committer = CommitFunc(func(context.Context, *Tx) error {
return txDriver.tx.Commit()
})
tx.mu.Lock()
hooks := append([]CommitHook(nil), tx.onCommit...)
tx.mu.Unlock()
for i := len(hooks) - 1; i >= 0; i-- {
fn = hooks[i](fn)
}
return fn.Commit(tx.ctx, tx)
}
// OnCommit adds a hook to call on commit.
func (tx *Tx) OnCommit(f CommitHook) {
tx.mu.Lock()
defer tx.mu.Unlock()
tx.onCommit = append(tx.onCommit, f)
}
type (
// Rollbacker is the interface that wraps the Rollback method.
Rollbacker interface {
Rollback(context.Context, *Tx) error
}
// The RollbackFunc type is an adapter to allow the use of ordinary
// function as a Rollbacker. If f is a function with the appropriate
// signature, RollbackFunc(f) is a Rollbacker that calls f.
RollbackFunc func(context.Context, *Tx) error
// RollbackHook defines the "rollback middleware". A function that gets a Rollbacker
// and returns a Rollbacker. For example:
//
// hook := func(next ent.Rollbacker) ent.Rollbacker {
// return ent.RollbackFunc(func(ctx context.Context, tx *ent.Tx) error {
// // Do some stuff before.
// if err := next.Rollback(ctx, tx); err != nil {
// return err
// }
// // Do some stuff after.
// return nil
// })
// }
//
RollbackHook func(Rollbacker) Rollbacker
)
// Rollback calls f(ctx, m).
func (f RollbackFunc) Rollback(ctx context.Context, tx *Tx) error {
return f(ctx, tx)
}
// Rollback rollbacks the transaction.
func (tx *Tx) Rollback() error {
txDriver := tx.config.driver.(*txDriver)
var fn Rollbacker = RollbackFunc(func(context.Context, *Tx) error {
return txDriver.tx.Rollback()
})
tx.mu.Lock()
hooks := append([]RollbackHook(nil), tx.onRollback...)
tx.mu.Unlock()
for i := len(hooks) - 1; i >= 0; i-- {
fn = hooks[i](fn)
}
return fn.Rollback(tx.ctx, tx)
}
// OnRollback adds a hook to call on rollback.
func (tx *Tx) OnRollback(f RollbackHook) {
tx.mu.Lock()
defer tx.mu.Unlock()
tx.onRollback = append(tx.onRollback, f)
}
// Client returns a Client that binds to current transaction.
func (tx *Tx) Client() *Client {
tx.clientOnce.Do(func() {
tx.client = &Client{config: tx.config}
tx.client.init()
})
return tx.client
}
func (tx *Tx) init() {
tx.Revision = NewRevisionClient(tx.config)
}
// txDriver wraps the given dialect.Tx with a nop dialect.Driver implementation.
// The idea is to support transactions without adding any extra code to the builders.
// When a builder calls to driver.Tx(), it gets the same dialect.Tx instance.
// Commit and Rollback are nop for the internal builders and the user must call one
// of them in order to commit or rollback the transaction.
//
// If a closed transaction is embedded in one of the generated entities, and the entity
// applies a query, for example: Revision.QueryXXX(), the query will be executed
// through the driver which created this transaction.
//
// Note that txDriver is not goroutine safe.
type txDriver struct {
// the driver we started the transaction from.
drv dialect.Driver
// tx is the underlying transaction.
tx dialect.Tx
}
// newTx creates a new transactional driver.
func newTx(ctx context.Context, drv dialect.Driver) (*txDriver, error) {
tx, err := drv.Tx(ctx)
if err != nil {
return nil, err
}
return &txDriver{tx: tx, drv: drv}, nil
}
// Tx returns the transaction wrapper (txDriver) to avoid Commit or Rollback calls
// from the internal builders. Should be called only by the internal builders.
func (tx *txDriver) Tx(context.Context) (dialect.Tx, error) { return tx, nil }
// Dialect returns the dialect of the driver we started the transaction from.
func (tx *txDriver) Dialect() string { return tx.drv.Dialect() }
// Close is a nop close.
func (*txDriver) Close() error { return nil }
// Commit is a nop commit for the internal builders.
// User must call `Tx.Commit` in order to commit the transaction.
func (*txDriver) Commit() error { return nil }
// Rollback is a nop rollback for the internal builders.
// User must call `Tx.Rollback` in order to rollback the transaction.
func (*txDriver) Rollback() error { return nil }
// Exec calls tx.Exec.
func (tx *txDriver) Exec(ctx context.Context, query string, args, v interface{}) error {
return tx.tx.Exec(ctx, query, args, v)
}
// Query calls tx.Query.
func (tx *txDriver) Query(ctx context.Context, query string, args, v interface{}) error {
return tx.tx.Query(ctx, query, args, v)
}
var _ dialect.Driver = (*txDriver)(nil)
// ExecContext allows calling the underlying ExecContext method of the transaction if it is supported by it.
// See, database/sql#Tx.ExecContext for more information.
func (tx *txDriver) ExecContext(ctx context.Context, query string, args ...interface{}) (stdsql.Result, error) {
ex, ok := tx.tx.(interface {
ExecContext(context.Context, string, ...interface{}) (stdsql.Result, error)
})
if !ok {
return nil, fmt.Errorf("Tx.ExecContext is not supported")
}
return ex.ExecContext(ctx, query, args...)
}
// QueryContext allows calling the underlying QueryContext method of the transaction if it is supported by it.
// See, database/sql#Tx.QueryContext for more information.
func (tx *txDriver) QueryContext(ctx context.Context, query string, args ...interface{}) (*stdsql.Rows, error) {
q, ok := tx.tx.(interface {
QueryContext(context.Context, string, ...interface{}) (*stdsql.Rows, error)
})
if !ok {
return nil, fmt.Errorf("Tx.QueryContext is not supported")
}
return q.QueryContext(ctx, query, args...)
}
atlas-0.7.2/cmd/atlas/internal/migrate/migrate.go 0000664 0000000 0000000 00000011433 14314555116 0021725 0 ustar 00root root 0000000 0000000 // Copyright 2021-present The Atlas Authors. All rights reserved.
// This source code is licensed under the Apache 2.0 license found
// in the LICENSE file in the root directory of this source tree.
package migrate
import (
"context"
"ariga.io/atlas/cmd/atlas/internal/migrate/ent"
"ariga.io/atlas/cmd/atlas/internal/migrate/ent/revision"
"ariga.io/atlas/sql/migrate"
"ariga.io/atlas/sql/schema"
"ariga.io/atlas/sql/sqlclient"
"entgo.io/ent/dialect"
"entgo.io/ent/dialect/sql"
entschema "entgo.io/ent/dialect/sql/schema"
)
type (
// EntRevisions provides implementation for the migrate.RevisionReadWriter interface.
EntRevisions struct {
ac *sqlclient.Client // underlying Atlas client
ec *ent.Client // underlying Ent client
schema string // name of the schema the revision table resides in
}
// Option allows to configure EntRevisions by using functional arguments.
Option func(*EntRevisions) error
)
// NewEntRevisions creates a new EntRevisions with the given sqlclient.Client.
func NewEntRevisions(ctx context.Context, ac *sqlclient.Client, opts ...Option) (*EntRevisions, error) {
r := &EntRevisions{ac: ac}
for _, opt := range opts {
if err := opt(r); err != nil {
return nil, err
}
}
// Create the connection with the underlying migrate.Driver to have it inside a possible transaction.
entopts := []ent.Option{ent.Driver(sql.NewDriver(r.ac.Name, sql.Conn{ExecQuerier: r.ac.Driver}))}
// SQLite does not support multiple schema, therefore schema-config is only needed for other dialects.
if r.ac.Name != dialect.SQLite {
// Make sure the schema to store the revisions table in does exist.
_, err := r.ac.InspectSchema(ctx, r.schema, &schema.InspectOptions{Mode: schema.InspectSchemas})
if err != nil && !schema.IsNotExistError(err) {
return nil, err
}
if schema.IsNotExistError(err) {
if err := r.ac.ApplyChanges(ctx, []schema.Change{
&schema.AddSchema{S: &schema.Schema{Name: r.schema}},
}); err != nil {
return nil, err
}
}
// Tell Ent to operate on a given schema.
if r.schema != "" {
entopts = append(entopts, ent.AlternateSchema(ent.SchemaConfig{Revision: r.schema}))
}
}
// Instantiate the Ent client and migrate the revision schema.
r.ec = ent.NewClient(entopts...)
return r, nil
}
// WithSchema configures the schema to use for the revision table.
func WithSchema(s string) Option {
return func(r *EntRevisions) error {
r.schema = s
return nil
}
}
// Ident returns the table identifier.
func (r *EntRevisions) Ident() *migrate.TableIdent {
return &migrate.TableIdent{Name: revision.Table, Schema: r.schema}
}
// ReadRevision reads a revision from the revisions table.
//
// ReadRevision will not return results only saved in cache.
func (r *EntRevisions) ReadRevision(ctx context.Context, v string) (*migrate.Revision, error) {
rev, err := r.ec.Revision.Get(ctx, v)
if err != nil && !ent.IsNotFound(err) {
return nil, err
}
if ent.IsNotFound(err) {
return nil, migrate.ErrRevisionNotExist
}
return rev.AtlasRevision(), nil
}
// ReadRevisions reads the revisions from the revisions table.
//
// ReadRevisions will not return results only saved to cache.
func (r *EntRevisions) ReadRevisions(ctx context.Context) ([]*migrate.Revision, error) {
revs, err := r.ec.Revision.Query().Order(ent.Asc(revision.FieldID)).All(ctx)
if err != nil {
return nil, err
}
ret := make([]*migrate.Revision, len(revs))
for i, rev := range revs {
ret[i] = rev.AtlasRevision()
}
return ret, nil
}
// WriteRevision writes a revision to the revisions table.
func (r *EntRevisions) WriteRevision(ctx context.Context, rev *migrate.Revision) error {
return r.ec.Revision.Create().
SetRevision(rev).
OnConflict(sql.ConflictColumns(revision.FieldID)).
UpdateNewValues().
Exec(ctx)
}
// DeleteRevision deletes a revision from the revisions table.
func (r *EntRevisions) DeleteRevision(ctx context.Context, v string) error {
return r.ec.Revision.DeleteOneID(v).Exec(ctx)
}
// Migrate attempts to create / update the revisions table. This is separated since Ent attempts to wrap the migration
// execution in a transaction and assumes the underlying connection is of type *sql.DB, which is not true for actually
// reading and writing revisions.
func (r *EntRevisions) Migrate(ctx context.Context) error {
c := ent.NewClient(ent.Driver(sql.OpenDB(r.ac.Name, r.ac.DB)))
// Ensure the ent client is bound to the requested revision schema. Open a new connection, if not.
if r.ac.Name != dialect.SQLite && r.ac.URL.Schema != r.schema {
sc, err := sqlclient.OpenURL(ctx, r.ac.URL.URL, sqlclient.OpenSchema(r.schema))
if err != nil {
return err
}
defer sc.Close()
c = ent.NewClient(ent.Driver(sql.OpenDB(sc.Name, sc.DB)))
}
return c.Schema.Create(ctx, entschema.WithDropColumn(true))
}
var _ migrate.RevisionReadWriter = (*EntRevisions)(nil)
atlas-0.7.2/cmd/atlas/internal/migrate/migrate_test.go 0000664 0000000 0000000 00000001711 14314555116 0022762 0 ustar 00root root 0000000 0000000 // Copyright 2021-present The Atlas Authors. All rights reserved.
// This source code is licensed under the Apache 2.0 license found
// in the LICENSE file in the root directory of this source tree.
package migrate
import (
"context"
"fmt"
"path/filepath"
"testing"
"ariga.io/atlas/cmd/atlas/internal/migrate/ent/revision"
"ariga.io/atlas/sql/sqlclient"
_ "github.com/mattn/go-sqlite3"
"github.com/stretchr/testify/require"
)
func TestNewEntRevisions(t *testing.T) {
c, err := sqlclient.Open(
context.Background(),
fmt.Sprintf("sqlite://%s?cache=shared&mode=memory&_fk=true", filepath.Join(t.TempDir(), "revision")),
)
require.NoError(t, err)
r, err := NewEntRevisions(context.Background(), c)
require.NoError(t, err)
require.NoError(t, r.Migrate(context.Background()))
s, err := c.Driver.InspectSchema(context.Background(), "", nil)
require.NoError(t, err)
require.Len(t, s.Tables, 1)
_, ok := s.Table(revision.Table)
require.True(t, ok)
}
atlas-0.7.2/cmd/atlas/internal/sqlparse/ 0000775 0000000 0000000 00000000000 14314555116 0020146 5 ustar 00root root 0000000 0000000 atlas-0.7.2/cmd/atlas/internal/sqlparse/myparse/ 0000775 0000000 0000000 00000000000 14314555116 0021626 5 ustar 00root root 0000000 0000000 atlas-0.7.2/cmd/atlas/internal/sqlparse/myparse/myparse.go 0000664 0000000 0000000 00000012074 14314555116 0023641 0 ustar 00root root 0000000 0000000 // Copyright 2021-present The Atlas Authors. All rights reserved.
// This source code is licensed under the Apache 2.0 license found
// in the LICENSE file in the root directory of this source tree.
package myparse
import (
"fmt"
"ariga.io/atlas/cmd/atlas/internal/sqlparse/parseutil"
"ariga.io/atlas/sql/migrate"
"ariga.io/atlas/sql/schema"
"github.com/pingcap/tidb/parser"
"github.com/pingcap/tidb/parser/ast"
"github.com/pingcap/tidb/parser/mysql"
_ "github.com/pingcap/tidb/parser/test_driver"
"golang.org/x/exp/slices"
)
// Parser implements the sqlparse.Parser
type Parser struct{}
// ColumnFilledBefore checks if the column was filled before the given position.
func (p *Parser) ColumnFilledBefore(f migrate.File, t *schema.Table, c *schema.Column, pos int) (bool, error) {
return parseutil.MatchStmtBefore(f, pos, func(s *migrate.Stmt) (bool, error) {
stmt, err := parser.New().ParseOneStmt(s.Text, "", "")
if err != nil {
return false, err
}
u, ok := stmt.(*ast.UpdateStmt)
// Ensure the table was updated.
if !ok || !tableUpdated(u, t) {
return false, nil
}
// Accept UPDATE that fills all rows or those with NULL values as we cannot
// determine if NULL values were filled in case there is a custom filtering.
affectC := func() bool {
if u.Where == nil {
return true
}
is, ok := u.Where.(*ast.IsNullExpr)
if !ok || is.Not {
return false
}
n, ok := is.Expr.(*ast.ColumnNameExpr)
return ok && n.Name.Name.O == c.Name
}()
idx := slices.IndexFunc(u.List, func(a *ast.Assignment) bool {
return a.Column.Name.String() == c.Name && a.Expr != nil && a.Expr.GetType().GetType() != mysql.TypeNull
})
// Ensure the column was filled.
return affectC && idx != -1, nil
})
}
// FixChange fixes the changes according to the given statement.
func (p *Parser) FixChange(d migrate.Driver, s string, changes schema.Changes) (schema.Changes, error) {
stmt, err := parser.New().ParseOneStmt(s, "", "")
if err != nil {
return nil, err
}
if len(changes) == 0 {
return changes, nil
}
switch stmt := stmt.(type) {
case *ast.AlterTableStmt:
if changes, err = renameTable(d, stmt, changes); err != nil {
return nil, err
}
modify, ok := changes[0].(*schema.ModifyTable)
if !ok {
return nil, fmt.Errorf("expected modify-table change for alter-table statement, but got: %T", changes[0])
}
for _, r := range renameColumns(stmt) {
parseutil.RenameColumn(modify, r)
}
for _, r := range renameIndexes(stmt) {
parseutil.RenameIndex(modify, r)
}
case *ast.RenameTableStmt:
for _, t := range stmt.TableToTables {
changes = parseutil.RenameTable(
changes,
&parseutil.Rename{
From: t.OldTable.Name.O,
To: t.NewTable.Name.O,
})
}
}
return changes, nil
}
// renameColumns returns all renamed columns that exist in the statement.
func renameColumns(stmt *ast.AlterTableStmt) (rename []*parseutil.Rename) {
for _, s := range stmt.Specs {
if s.Tp == ast.AlterTableRenameColumn {
rename = append(rename, &parseutil.Rename{
From: s.OldColumnName.Name.O,
To: s.NewColumnName.Name.O,
})
}
}
return
}
// renameIndexes returns all renamed indexes that exist in the statement.
func renameIndexes(stmt *ast.AlterTableStmt) (rename []*parseutil.Rename) {
for _, s := range stmt.Specs {
if s.Tp == ast.AlterTableRenameIndex {
rename = append(rename, &parseutil.Rename{
From: s.FromKey.O,
To: s.ToKey.O,
})
}
}
return
}
// renameTable fixes the changes from ALTER command with RENAME into ModifyTable and RenameTable.
func renameTable(drv migrate.Driver, stmt *ast.AlterTableStmt, changes schema.Changes) (schema.Changes, error) {
var r *ast.AlterTableSpec
for _, s := range stmt.Specs {
if s.Tp == ast.AlterTableRenameTable {
r = s
break
}
}
if r == nil {
return changes, nil
}
if len(changes) != 2 {
return nil, fmt.Errorf("unexected number fo changes for ALTER command with RENAME clause: %d", len(changes))
}
i, j := changes.IndexDropTable(stmt.Table.Name.O), changes.IndexAddTable(r.NewTable.Name.O)
if i == -1 {
return nil, fmt.Errorf("DropTable %q change was not found in changes", stmt.Table.Name)
}
if j == -1 {
return nil, fmt.Errorf("AddTable %q change was not found in changes", r.NewTable.Name)
}
fromT, toT := changes[0].(*schema.DropTable).T, changes[1].(*schema.AddTable).T
fromT.Name = toT.Name
diff, err := drv.TableDiff(fromT, toT)
if err != nil {
return nil, err
}
changeT := *toT
changeT.Name = stmt.Table.Name.O
return schema.Changes{
// Modify the table first.
&schema.ModifyTable{T: &changeT, Changes: diff},
// Then, apply the RENAME.
&schema.RenameTable{From: &changeT, To: toT},
}, nil
}
// tableUpdated checks if the table was updated in the statement.
func tableUpdated(u *ast.UpdateStmt, t *schema.Table) bool {
if u.TableRefs == nil || u.TableRefs.TableRefs == nil || u.TableRefs.TableRefs.Left == nil {
return false
}
ts, ok := u.TableRefs.TableRefs.Left.(*ast.TableSource)
if !ok {
return false
}
n, ok := ts.Source.(*ast.TableName)
return ok && n.Name.O == t.Name && (n.Schema.O == "" || n.Schema.O == t.Schema.Name)
}
atlas-0.7.2/cmd/atlas/internal/sqlparse/myparse/myparse_test.go 0000664 0000000 0000000 00000013723 14314555116 0024702 0 ustar 00root root 0000000 0000000 // Copyright 2021-present The Atlas Authors. All rights reserved.
// This source code is licensed under the Apache 2.0 license found
// in the LICENSE file in the root directory of this source tree.
package myparse_test
import (
"strconv"
"testing"
"ariga.io/atlas/cmd/atlas/internal/sqlparse/myparse"
"ariga.io/atlas/sql/migrate"
"ariga.io/atlas/sql/schema"
"github.com/stretchr/testify/require"
)
func TestFixChange_RenameColumns(t *testing.T) {
var p myparse.Parser
_, err := p.FixChange(
nil,
"ALTER TABLE t RENAME COLUMN c1 TO c2",
schema.Changes{&schema.AddTable{}},
)
require.Error(t, err)
changes, err := p.FixChange(
nil,
"ALTER TABLE t RENAME COLUMN c1 TO c2",
schema.Changes{
&schema.ModifyTable{
Changes: schema.Changes{
&schema.DropColumn{C: schema.NewColumn("c1")},
&schema.AddColumn{C: schema.NewColumn("c2")},
},
},
},
)
require.NoError(t, err)
require.Equal(
t,
schema.Changes{
&schema.ModifyTable{
Changes: schema.Changes{
&schema.RenameColumn{From: schema.NewColumn("c1"), To: schema.NewColumn("c2")},
},
},
},
changes,
)
changes, err = p.FixChange(
nil,
"ALTER TABLE t ADD INDEX i(id), RENAME COLUMN c1 TO c2, ADD COLUMN c3 int, DROP COLUMN c4",
schema.Changes{
&schema.ModifyTable{
Changes: schema.Changes{
&schema.AddIndex{I: schema.NewIndex("i").AddColumns(schema.NewColumn("id"))},
&schema.DropColumn{C: schema.NewColumn("c1")},
&schema.AddColumn{C: schema.NewColumn("c2")},
&schema.AddColumn{C: schema.NewColumn("c3")},
&schema.AddColumn{C: schema.NewColumn("c4")},
},
},
},
)
require.NoError(t, err)
require.Equal(
t,
schema.Changes{
&schema.ModifyTable{
Changes: schema.Changes{
&schema.AddIndex{I: schema.NewIndex("i").AddColumns(schema.NewColumn("id"))},
&schema.RenameColumn{From: schema.NewColumn("c1"), To: schema.NewColumn("c2")},
&schema.AddColumn{C: schema.NewColumn("c3")},
&schema.AddColumn{C: schema.NewColumn("c4")},
},
},
},
changes,
)
}
func TestFixChange_RenameIndexes(t *testing.T) {
var p myparse.Parser
changes, err := p.FixChange(
nil,
"ALTER TABLE t RENAME Index i1 TO i2",
schema.Changes{
&schema.ModifyTable{
Changes: schema.Changes{
&schema.DropIndex{I: schema.NewIndex("i1")},
&schema.AddIndex{I: schema.NewIndex("i2")},
},
},
},
)
require.NoError(t, err)
require.Equal(
t,
schema.Changes{
&schema.ModifyTable{
Changes: schema.Changes{
&schema.RenameIndex{From: schema.NewIndex("i1"), To: schema.NewIndex("i2")},
},
},
},
changes,
)
}
func TestFixChange_RenameTable(t *testing.T) {
var p myparse.Parser
changes, err := p.FixChange(
nil,
"RENAME TABLE t1 TO t2",
schema.Changes{
&schema.DropTable{T: schema.NewTable("t1")},
&schema.AddTable{T: schema.NewTable("t2")},
},
)
require.NoError(t, err)
require.Equal(
t,
schema.Changes{
&schema.RenameTable{From: schema.NewTable("t1"), To: schema.NewTable("t2")},
},
changes,
)
changes, err = p.FixChange(
nil,
"RENAME TABLE t1 TO t2, t3 TO t4",
schema.Changes{
&schema.DropTable{T: schema.NewTable("t1")},
&schema.AddTable{T: schema.NewTable("t2")},
&schema.DropTable{T: schema.NewTable("t3")},
&schema.AddTable{T: schema.NewTable("t4")},
},
)
require.NoError(t, err)
require.Equal(
t,
schema.Changes{
&schema.RenameTable{From: schema.NewTable("t1"), To: schema.NewTable("t2")},
&schema.RenameTable{From: schema.NewTable("t3"), To: schema.NewTable("t4")},
},
changes,
)
}
func TestFixChange_AlterAndRename(t *testing.T) {
var (
p myparse.Parser
drv = &mockDriver{}
)
drv.changes = append(drv.changes, &schema.AddColumn{C: schema.NewIntColumn("c2", "int")})
changes, err := p.FixChange(
drv,
"ALTER TABLE t1 RENAME TO t2, ADD COLUMN c2 int",
schema.Changes{
&schema.DropTable{T: schema.NewTable("t1").AddColumns(schema.NewIntColumn("c1", "int"))},
&schema.AddTable{T: schema.NewTable("t2").AddColumns(schema.NewIntColumn("c1", "int"), schema.NewIntColumn("c2", "int"))},
},
)
require.NoError(t, err)
require.Equal(
t,
schema.Changes{
&schema.ModifyTable{
T: schema.NewTable("t1").AddColumns(schema.NewIntColumn("c1", "int"), schema.NewIntColumn("c2", "int")),
Changes: schema.Changes{
&schema.AddColumn{C: schema.NewIntColumn("c2", "int")},
},
},
&schema.RenameTable{
From: schema.NewTable("t1").AddColumns(schema.NewIntColumn("c1", "int"), schema.NewIntColumn("c2", "int")),
To: schema.NewTable("t2").AddColumns(schema.NewIntColumn("c1", "int"), schema.NewIntColumn("c2", "int")),
},
},
changes,
)
}
func TestColumnFilledBefore(t *testing.T) {
for i, tt := range []struct {
file string
pos int
wantFilled bool
wantErr bool
}{
{
file: `UPDATE t SET c = NULL;`,
pos: 100,
},
{
file: `UPDATE t SET c = 2;`,
pos: 100,
wantFilled: true,
},
{
file: `UPDATE t SET c = 2 WHERE c IS NULL;`,
pos: 100,
wantFilled: true,
},
{
file: `UPDATE t SET c = 2 WHERE c IS NOT NULL;`,
pos: 100,
wantFilled: false,
},
{
file: `UPDATE t SET c = 2 WHERE c <> NULL`,
pos: 100,
wantFilled: false,
},
{
file: `
ALTER TABLE t MODIFY COLUMN c INT NOT NULL;
UPDATE t SET c = 2 WHERE c IS NULL;
`,
pos: 2,
wantFilled: false,
},
{
file: `
UPDATE t SET c = 2 WHERE c IS NULL;
ALTER TABLE t MODIFY COLUMN c INT NOT NULL;
`,
pos: 30,
wantFilled: true,
},
} {
t.Run(strconv.Itoa(i), func(t *testing.T) {
var (
p myparse.Parser
f = migrate.NewLocalFile("file", []byte(tt.file))
)
filled, err := p.ColumnFilledBefore(f, schema.NewTable("t"), schema.NewColumn("c"), tt.pos)
require.Equal(t, err != nil, tt.wantErr, err)
require.Equal(t, filled, tt.wantFilled)
})
}
}
type mockDriver struct {
migrate.Driver
changes schema.Changes
}
func (d mockDriver) TableDiff(_, _ *schema.Table) ([]schema.Change, error) {
return d.changes, nil
}
atlas-0.7.2/cmd/atlas/internal/sqlparse/parseutil/ 0000775 0000000 0000000 00000000000 14314555116 0022156 5 ustar 00root root 0000000 0000000 atlas-0.7.2/cmd/atlas/internal/sqlparse/parseutil/parseutil.go 0000664 0000000 0000000 00000004663 14314555116 0024526 0 ustar 00root root 0000000 0000000 // Copyright 2021-present The Atlas Authors. All rights reserved.
// This source code is licensed under the Apache 2.0 license found
// in the LICENSE file in the root directory of this source tree.
// Package parseutil exposes shared functions used by the different parsers.
package parseutil
import (
"ariga.io/atlas/sql/migrate"
"ariga.io/atlas/sql/schema"
"golang.org/x/exp/slices"
)
// Rename describes rename of a resource.
type Rename struct {
From, To string
}
// RenameColumn patches DROP/ADD column commands to RENAME.
func RenameColumn(modify *schema.ModifyTable, r *Rename) {
changes := schema.Changes(modify.Changes)
i := changes.IndexDropColumn(r.From)
j := changes.IndexAddColumn(r.To)
if i != -1 && j != -1 {
changes[max(i, j)] = &schema.RenameColumn{
From: changes[i].(*schema.DropColumn).C,
To: changes[j].(*schema.AddColumn).C,
}
changes.RemoveIndex(min(i, j))
modify.Changes = changes
}
}
// RenameIndex patches DROP/ADD index commands to RENAME.
func RenameIndex(modify *schema.ModifyTable, r *Rename) {
changes := schema.Changes(modify.Changes)
i := changes.IndexDropIndex(r.From)
j := changes.IndexAddIndex(r.To)
if i != -1 && j != -1 {
changes[max(i, j)] = &schema.RenameIndex{
From: changes[i].(*schema.DropIndex).I,
To: changes[j].(*schema.AddIndex).I,
}
changes.RemoveIndex(min(i, j))
modify.Changes = changes
}
}
// RenameTable patches DROP/ADD table commands to RENAME.
func RenameTable(changes schema.Changes, r *Rename) schema.Changes {
i := changes.IndexDropTable(r.From)
j := changes.IndexAddTable(r.To)
if i != -1 && j != -1 {
changes[max(i, j)] = &schema.RenameTable{
From: changes[i].(*schema.DropTable).T,
To: changes[j].(*schema.AddTable).T,
}
changes.RemoveIndex(min(i, j))
}
return changes
}
// MatchStmtBefore reports if the file contains any statement that matches the predicate before the given position.
func MatchStmtBefore(f migrate.File, pos int, p func(*migrate.Stmt) (bool, error)) (bool, error) {
stmts, err := f.StmtDecls()
if err != nil {
return false, err
}
i := slices.IndexFunc(stmts, func(s *migrate.Stmt) bool {
return s.Pos >= pos
})
if i != -1 {
stmts = stmts[:i]
}
for _, s := range stmts {
m, err := p(s)
if err != nil {
return false, err
}
if m {
return true, nil
}
}
return false, nil
}
func max(i, j int) int {
if i > j {
return i
}
return j
}
func min(i, j int) int {
if i < j {
return i
}
return j
}
atlas-0.7.2/cmd/atlas/internal/sqlparse/pgparse/ 0000775 0000000 0000000 00000000000 14314555116 0021607 5 ustar 00root root 0000000 0000000 atlas-0.7.2/cmd/atlas/internal/sqlparse/pgparse/pgparse.go 0000664 0000000 0000000 00000007000 14314555116 0023574 0 ustar 00root root 0000000 0000000 // Copyright 2021-present The Atlas Authors. All rights reserved.
// This source code is licensed under the Apache 2.0 license found
// in the LICENSE file in the root directory of this source tree.
package pgparse
import (
"fmt"
"ariga.io/atlas/cmd/atlas/internal/sqlparse/parseutil"
"ariga.io/atlas/sql/migrate"
"ariga.io/atlas/sql/schema"
"github.com/auxten/postgresql-parser/pkg/sql/parser"
"github.com/auxten/postgresql-parser/pkg/sql/sem/tree"
"golang.org/x/exp/slices"
)
// Parser implements the sqlparse.Parser
type Parser struct{}
// ColumnFilledBefore checks if the column was filled before the given position.
func (p *Parser) ColumnFilledBefore(f migrate.File, t *schema.Table, c *schema.Column, pos int) (bool, error) {
return parseutil.MatchStmtBefore(f, pos, func(s *migrate.Stmt) (bool, error) {
stmt, err := parser.ParseOne(s.Text)
if err != nil {
return false, err
}
u, ok := stmt.AST.(*tree.Update)
if !ok || !tableUpdated(u, t) {
return false, nil
}
// Accept UPDATE that fills all rows or those with NULL values as we cannot
// determine if NULL values were filled in case there is a custom filtering.
affectC := func() bool {
if u.Where == nil {
return true
}
x, ok := u.Where.Expr.(*tree.ComparisonExpr)
if !ok || x.Operator != tree.IsNotDistinctFrom || x.SubOperator != tree.EQ {
return false
}
return x.Left.String() == c.Name && x.Right == tree.DNull
}()
idx := slices.IndexFunc(u.Exprs, func(x *tree.UpdateExpr) bool {
return slices.Contains(x.Names, tree.Name(c.Name)) && x.Expr != tree.DNull
})
// Ensure the column was filled.
return affectC && idx != -1, nil
})
}
// FixChange fixes the changes according to the given statement.
func (p *Parser) FixChange(_ migrate.Driver, s string, changes schema.Changes) (schema.Changes, error) {
stmt, err := parser.ParseOne(s)
if err != nil {
return nil, err
}
switch stmt := stmt.AST.(type) {
case *tree.AlterTable:
if r, ok := renameColumn(stmt); ok {
modify, err := expectModify(changes)
if err != nil {
return nil, err
}
parseutil.RenameColumn(modify, r)
}
case *tree.RenameIndex:
modify, err := expectModify(changes)
if err != nil {
return nil, err
}
parseutil.RenameIndex(modify, &parseutil.Rename{
From: stmt.Index.String(),
To: stmt.NewName.String(),
})
case *tree.RenameTable:
changes = parseutil.RenameTable(changes, &parseutil.Rename{
From: stmt.Name.String(),
To: stmt.NewName.String(),
})
}
return changes, nil
}
// renameColumn returns the renamed column exists in the statement, is any.
func renameColumn(stmt *tree.AlterTable) (*parseutil.Rename, bool) {
for _, c := range stmt.Cmds {
if r, ok := c.(*tree.AlterTableRenameColumn); ok {
return &parseutil.Rename{
From: r.Column.String(),
To: r.NewName.String(),
}, true
}
}
return nil, false
}
func expectModify(changes schema.Changes) (*schema.ModifyTable, error) {
if len(changes) != 1 {
return nil, fmt.Errorf("unexected number fo changes: %d", len(changes))
}
modify, ok := changes[0].(*schema.ModifyTable)
if !ok {
return nil, fmt.Errorf("expected modify-table change for alter-table statement, but got: %T", changes[0])
}
return modify, nil
}
// tableUpdated checks if the table was updated in the statement.
func tableUpdated(u *tree.Update, t *schema.Table) bool {
at, ok := u.Table.(*tree.AliasedTableExpr)
if !ok {
return false
}
n, ok := at.Expr.(*tree.TableName)
return ok && n.Table() == t.Name && (n.Schema() == "" || n.Schema() == t.Schema.Name)
}
atlas-0.7.2/cmd/atlas/internal/sqlparse/pgparse/pgparse_test.go 0000664 0000000 0000000 00000007120 14314555116 0024636 0 ustar 00root root 0000000 0000000 // Copyright 2021-present The Atlas Authors. All rights reserved.
// This source code is licensed under the Apache 2.0 license found
// in the LICENSE file in the root directory of this source tree.
package pgparse_test
import (
"strconv"
"testing"
"ariga.io/atlas/cmd/atlas/internal/sqlparse/pgparse"
"ariga.io/atlas/sql/migrate"
"ariga.io/atlas/sql/schema"
"github.com/stretchr/testify/require"
)
func TestFixChange_RenameColumns(t *testing.T) {
var p pgparse.Parser
_, err := p.FixChange(
nil,
"ALTER TABLE t RENAME COLUMN c1 TO c2",
nil,
)
require.Error(t, err)
_, err = p.FixChange(
nil,
"ALTER TABLE t RENAME COLUMN c1 TO c2",
schema.Changes{&schema.AddTable{}},
)
require.Error(t, err)
changes, err := p.FixChange(
nil,
"ALTER TABLE t RENAME COLUMN c1 TO c2",
schema.Changes{
&schema.ModifyTable{
Changes: schema.Changes{
&schema.DropColumn{C: schema.NewColumn("c1")},
&schema.AddColumn{C: schema.NewColumn("c2")},
},
},
},
)
require.NoError(t, err)
require.Equal(
t,
schema.Changes{
&schema.ModifyTable{
Changes: schema.Changes{
&schema.RenameColumn{From: schema.NewColumn("c1"), To: schema.NewColumn("c2")},
},
},
},
changes,
)
}
func TestFixChange_RenameIndexes(t *testing.T) {
var p pgparse.Parser
changes, err := p.FixChange(
nil,
"ALTER INDEX IF EXISTS i1 RENAME TO i2",
schema.Changes{
&schema.ModifyTable{
Changes: schema.Changes{
&schema.DropIndex{I: schema.NewIndex("i1")},
&schema.AddIndex{I: schema.NewIndex("i2")},
},
},
},
)
require.NoError(t, err)
require.Equal(
t,
schema.Changes{
&schema.ModifyTable{
Changes: schema.Changes{
&schema.RenameIndex{From: schema.NewIndex("i1"), To: schema.NewIndex("i2")},
},
},
},
changes,
)
}
func TestFixChange_RenameTable(t *testing.T) {
var p pgparse.Parser
changes, err := p.FixChange(
nil,
"ALTER TABLE t1 RENAME TO t2",
schema.Changes{
&schema.DropTable{T: schema.NewTable("t1")},
&schema.AddTable{T: schema.NewTable("t2")},
&schema.AddTable{T: schema.NewTable("t3")},
},
)
require.NoError(t, err)
require.Equal(
t,
schema.Changes{
&schema.RenameTable{From: schema.NewTable("t1"), To: schema.NewTable("t2")},
&schema.AddTable{T: schema.NewTable("t3")},
},
changes,
)
}
func TestColumnFilledBefore(t *testing.T) {
for i, tt := range []struct {
file string
pos int
wantFilled bool
wantErr bool
}{
{
file: `UPDATE t SET c = NULL;`,
pos: 100,
},
{
file: `UPDATE t SET c = 2;`,
},
{
file: `UPDATE t SET c = 2;`,
},
{
file: `UPDATE t SET c = 2;`,
pos: 100,
wantFilled: true,
},
{
file: `UPDATE t SET c = 2 WHERE c IS NULL;`,
pos: 100,
wantFilled: true,
},
{
file: `UPDATE t SET c = 2 WHERE c IS NOT NULL;`,
pos: 100,
wantFilled: false,
},
{
file: `UPDATE t SET c = 2 WHERE c <> NULL`,
pos: 100,
wantFilled: false,
},
{
file: `
ALTER TABLE t MODIFY COLUMN c INT NOT NULL;
UPDATE t SET c = 2 WHERE c IS NULL;
`,
pos: 2,
wantFilled: false,
},
{
file: `
UPDATE t SET c = 2 WHERE c IS NULL;
ALTER TABLE t MODIFY COLUMN c INT NOT NULL;
`,
pos: 30,
wantFilled: true,
},
} {
t.Run(strconv.Itoa(i), func(t *testing.T) {
var (
p pgparse.Parser
f = migrate.NewLocalFile("file", []byte(tt.file))
)
filled, err := p.ColumnFilledBefore(f, schema.NewTable("t"), schema.NewColumn("c"), tt.pos)
require.Equal(t, err != nil, tt.wantErr, err)
require.Equal(t, filled, tt.wantFilled)
})
}
}
atlas-0.7.2/cmd/atlas/internal/sqlparse/sqliteparse/ 0000775 0000000 0000000 00000000000 14314555116 0022502 5 ustar 00root root 0000000 0000000 atlas-0.7.2/cmd/atlas/internal/sqlparse/sqliteparse/Lexer.g4 0000664 0000000 0000000 00000016345 14314555116 0024026 0 ustar 00root root 0000000 0000000 /*
* The MIT License (MIT)
*
* Copyright (c) 2020 by Martin Mirchev
*
* Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
* associated documentation files (the "Software"), to deal in the Software without restriction,
* including without limitation the rights to use, copy, modify, merge, publish, distribute,
* sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all copies or
* substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
* NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
* DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*
* Project : sqlite-parser; an ANTLR4 grammar for SQLite https://github.com/bkiers/sqlite-parser
* Developed by : Bart Kiers, bart@big-o.nl
*/
// $antlr-format alignTrailingComments on, columnLimit 150, maxEmptyLinesToKeep 1, reflowComments off, useTab off
// $antlr-format allowShortRulesOnASingleLine on, alignSemicolons ownLine
lexer grammar Lexer;
options { caseInsensitive = true; }
SCOL: ';';
DOT: '.';
OPEN_PAR: '(';
CLOSE_PAR: ')';
COMMA: ',';
ASSIGN: '=';
STAR: '*';
PLUS: '+';
MINUS: '-';
TILDE: '~';
PIPE2: '||';
DIV: '/';
MOD: '%';
LT2: '<<';
GT2: '>>';
AMP: '&';
PIPE: '|';
LT: '<';
LT_EQ: '<=';
GT: '>';
GT_EQ: '>=';
EQ: '==';
NOT_EQ1: '!=';
NOT_EQ2: '<>';
// http://www.sqlite.org/lang_keywords.html
ABORT_: 'ABORT';
ACTION_: 'ACTION';
ADD_: 'ADD';
AFTER_: 'AFTER';
ALL_: 'ALL';
ALTER_: 'ALTER';
ANALYZE_: 'ANALYZE';
AND_: 'AND';
AS_: 'AS';
ASC_: 'ASC';
ATTACH_: 'ATTACH';
AUTOINCREMENT_: 'AUTOINCREMENT';
BEFORE_: 'BEFORE';
BEGIN_: 'BEGIN';
BETWEEN_: 'BETWEEN';
BY_: 'BY';
CASCADE_: 'CASCADE';
CASE_: 'CASE';
CAST_: 'CAST';
CHECK_: 'CHECK';
COLLATE_: 'COLLATE';
COLUMN_: 'COLUMN';
COMMIT_: 'COMMIT';
CONFLICT_: 'CONFLICT';
CONSTRAINT_: 'CONSTRAINT';
CREATE_: 'CREATE';
CROSS_: 'CROSS';
CURRENT_DATE_: 'CURRENT_DATE';
CURRENT_TIME_: 'CURRENT_TIME';
CURRENT_TIMESTAMP_: 'CURRENT_TIMESTAMP';
DATABASE_: 'DATABASE';
DEFAULT_: 'DEFAULT';
DEFERRABLE_: 'DEFERRABLE';
DEFERRED_: 'DEFERRED';
DELETE_: 'DELETE';
DESC_: 'DESC';
DETACH_: 'DETACH';
DISTINCT_: 'DISTINCT';
DROP_: 'DROP';
EACH_: 'EACH';
ELSE_: 'ELSE';
END_: 'END';
ESCAPE_: 'ESCAPE';
EXCEPT_: 'EXCEPT';
EXCLUSIVE_: 'EXCLUSIVE';
EXISTS_: 'EXISTS';
EXPLAIN_: 'EXPLAIN';
FAIL_: 'FAIL';
FOR_: 'FOR';
FOREIGN_: 'FOREIGN';
FROM_: 'FROM';
FULL_: 'FULL';
GLOB_: 'GLOB';
GROUP_: 'GROUP';
HAVING_: 'HAVING';
IF_: 'IF';
IGNORE_: 'IGNORE';
IMMEDIATE_: 'IMMEDIATE';
IN_: 'IN';
INDEX_: 'INDEX';
INDEXED_: 'INDEXED';
INITIALLY_: 'INITIALLY';
INNER_: 'INNER';
INSERT_: 'INSERT';
INSTEAD_: 'INSTEAD';
INTERSECT_: 'INTERSECT';
INTO_: 'INTO';
IS_: 'IS';
ISNULL_: 'ISNULL';
JOIN_: 'JOIN';
KEY_: 'KEY';
LEFT_: 'LEFT';
LIKE_: 'LIKE';
LIMIT_: 'LIMIT';
MATCH_: 'MATCH';
NATURAL_: 'NATURAL';
NO_: 'NO';
NOT_: 'NOT';
NOTNULL_: 'NOTNULL';
NULL_: 'NULL';
OF_: 'OF';
OFFSET_: 'OFFSET';
ON_: 'ON';
OR_: 'OR';
ORDER_: 'ORDER';
OUTER_: 'OUTER';
PLAN_: 'PLAN';
PRAGMA_: 'PRAGMA';
PRIMARY_: 'PRIMARY';
QUERY_: 'QUERY';
RAISE_: 'RAISE';
RECURSIVE_: 'RECURSIVE';
REFERENCES_: 'REFERENCES';
REGEXP_: 'REGEXP';
REINDEX_: 'REINDEX';
RELEASE_: 'RELEASE';
RENAME_: 'RENAME';
REPLACE_: 'REPLACE';
RESTRICT_: 'RESTRICT';
RETURNING_: 'RETURNING';
RIGHT_: 'RIGHT';
ROLLBACK_: 'ROLLBACK';
ROW_: 'ROW';
ROWS_: 'ROWS';
SAVEPOINT_: 'SAVEPOINT';
SELECT_: 'SELECT';
SET_: 'SET';
TABLE_: 'TABLE';
TEMP_: 'TEMP';
TEMPORARY_: 'TEMPORARY';
THEN_: 'THEN';
TO_: 'TO';
TRANSACTION_: 'TRANSACTION';
TRIGGER_: 'TRIGGER';
UNION_: 'UNION';
UNIQUE_: 'UNIQUE';
UPDATE_: 'UPDATE';
USING_: 'USING';
VACUUM_: 'VACUUM';
VALUES_: 'VALUES';
VIEW_: 'VIEW';
VIRTUAL_: 'VIRTUAL';
WHEN_: 'WHEN';
WHERE_: 'WHERE';
WITH_: 'WITH';
WITHOUT_: 'WITHOUT';
FIRST_VALUE_: 'FIRST_VALUE';
OVER_: 'OVER';
PARTITION_: 'PARTITION';
RANGE_: 'RANGE';
PRECEDING_: 'PRECEDING';
UNBOUNDED_: 'UNBOUNDED';
CURRENT_: 'CURRENT';
FOLLOWING_: 'FOLLOWING';
CUME_DIST_: 'CUME_DIST';
DENSE_RANK_: 'DENSE_RANK';
LAG_: 'LAG';
LAST_VALUE_: 'LAST_VALUE';
LEAD_: 'LEAD';
NTH_VALUE_: 'NTH_VALUE';
NTILE_: 'NTILE';
PERCENT_RANK_: 'PERCENT_RANK';
RANK_: 'RANK';
ROW_NUMBER_: 'ROW_NUMBER';
GENERATED_: 'GENERATED';
ALWAYS_: 'ALWAYS';
STORED_: 'STORED';
TRUE_: 'TRUE';
FALSE_: 'FALSE';
WINDOW_: 'WINDOW';
NULLS_: 'NULLS';
FIRST_: 'FIRST';
LAST_: 'LAST';
FILTER_: 'FILTER';
GROUPS_: 'GROUPS';
EXCLUDE_: 'EXCLUDE';
TIES_: 'TIES';
OTHERS_: 'OTHERS';
DO_: 'DO';
NOTHING_: 'NOTHING';
IDENTIFIER:
'"' (~'"' | '""')* '"'
| '`' (~'`' | '``')* '`'
| '[' ~']'* ']'
| [A-Z_] [A-Z_0-9]*
; // TODO check: needs more chars in set
NUMERIC_LITERAL: ((DIGIT+ ('.' DIGIT*)?) | ('.' DIGIT+)) ('E' [-+]? DIGIT+)? | '0x' HEX_DIGIT+;
BIND_PARAMETER: '?' DIGIT* | [:@$] IDENTIFIER;
STRING_LITERAL: '\'' ( ~'\'' | '\'\'')* '\'';
BLOB_LITERAL: 'X' STRING_LITERAL;
SINGLE_LINE_COMMENT: '--' ~[\r\n]* (('\r'? '\n') | EOF) -> channel(HIDDEN);
MULTILINE_COMMENT: '/*' .*? '*/' -> channel(HIDDEN);
SPACES: [ \u000B\t\r\n] -> channel(HIDDEN);
UNEXPECTED_CHAR: .;
fragment HEX_DIGIT: [0-9A-F];
fragment DIGIT: [0-9];
atlas-0.7.2/cmd/atlas/internal/sqlparse/sqliteparse/Parser.g4 0000664 0000000 0000000 00000045417 14314555116 0024205 0 ustar 00root root 0000000 0000000 /*
* The MIT License (MIT)
*
* Copyright (c) 2014 by Bart Kiers
*
* Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
* associated documentation files (the "Software"), to deal in the Software without restriction,
* including without limitation the rights to use, copy, modify, merge, publish, distribute,
* sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in all copies or
* substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
* NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
* DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*
* Project : sqlite-parser; an ANTLR4 grammar for SQLite https://github.com/bkiers/sqlite-parser
* Developed by:
* Bart Kiers, bart@big-o.nl
* Martin Mirchev, marti_2203@abv.bg
* Mike Lische, mike@lischke-online.de
*/
// $antlr-format alignTrailingComments on, columnLimit 130, minEmptyLines 1, maxEmptyLinesToKeep 1, reflowComments off
// $antlr-format useTab off, allowShortRulesOnASingleLine off, allowShortBlocksOnASingleLine on, alignSemicolons ownLine
parser grammar Parser;
options {
tokenVocab = Lexer;
}
parse: (sql_stmt_list)* EOF
;
sql_stmt_list:
SCOL* sql_stmt (SCOL+ sql_stmt)* SCOL*
;
sql_stmt: (EXPLAIN_ (QUERY_ PLAN_)?)? (
alter_table_stmt
| analyze_stmt
| attach_stmt
| begin_stmt
| commit_stmt
| create_index_stmt
| create_table_stmt
| create_trigger_stmt
| create_view_stmt
| create_virtual_table_stmt
| delete_stmt
| delete_stmt_limited
| detach_stmt
| drop_stmt
| insert_stmt
| pragma_stmt
| reindex_stmt
| release_stmt
| rollback_stmt
| savepoint_stmt
| select_stmt
| update_stmt
| update_stmt_limited
| vacuum_stmt
)
;
alter_table_stmt:
ALTER_ TABLE_ (schema_name DOT)? table_name (
RENAME_ (
TO_ new_table_name = table_name
| COLUMN_? old_column_name = column_name TO_ new_column_name = column_name
)
| ADD_ COLUMN_? column_def
| DROP_ COLUMN_? column_name
)
;
analyze_stmt:
ANALYZE_ (schema_name | (schema_name DOT)? table_or_index_name)?
;
attach_stmt:
ATTACH_ DATABASE_? expr AS_ schema_name
;
begin_stmt:
BEGIN_ (DEFERRED_ | IMMEDIATE_ | EXCLUSIVE_)? (
TRANSACTION_ transaction_name?
)?
;
commit_stmt: (COMMIT_ | END_) TRANSACTION_?
;
rollback_stmt:
ROLLBACK_ TRANSACTION_? (TO_ SAVEPOINT_? savepoint_name)?
;
savepoint_stmt:
SAVEPOINT_ savepoint_name
;
release_stmt:
RELEASE_ SAVEPOINT_? savepoint_name
;
create_index_stmt:
CREATE_ UNIQUE_? INDEX_ (IF_ NOT_ EXISTS_)? (schema_name DOT)? index_name ON_ table_name OPEN_PAR
indexed_column (COMMA indexed_column)* CLOSE_PAR (WHERE_ expr)?
;
indexed_column: (column_name | expr) (COLLATE_ collation_name)? asc_desc?
;
create_table_stmt:
CREATE_ (TEMP_ | TEMPORARY_)? TABLE_ (IF_ NOT_ EXISTS_)? (
schema_name DOT
)? table_name (
OPEN_PAR column_def (COMMA column_def)*? (COMMA table_constraint)* CLOSE_PAR (
WITHOUT_ row_ROW_ID = IDENTIFIER
)?
| AS_ select_stmt
)
;
column_def:
column_name type_name? column_constraint*
;
type_name:
name+? (
OPEN_PAR signed_number CLOSE_PAR
| OPEN_PAR signed_number COMMA signed_number CLOSE_PAR
)?
;
column_constraint: (CONSTRAINT_ name)? (
(PRIMARY_ KEY_ asc_desc? conflict_clause? AUTOINCREMENT_?)
| (NOT_ NULL_ | UNIQUE_) conflict_clause?
| CHECK_ OPEN_PAR expr CLOSE_PAR
| DEFAULT_ (signed_number | literal_value | OPEN_PAR expr CLOSE_PAR)
| COLLATE_ collation_name
| foreign_key_clause
| (GENERATED_ ALWAYS_)? AS_ OPEN_PAR expr CLOSE_PAR (
STORED_
| VIRTUAL_
)?
)
;
signed_number: (PLUS | MINUS)? NUMERIC_LITERAL
;
table_constraint: (CONSTRAINT_ name)? (
(PRIMARY_ KEY_ | UNIQUE_) OPEN_PAR indexed_column (
COMMA indexed_column
)* CLOSE_PAR conflict_clause?
| CHECK_ OPEN_PAR expr CLOSE_PAR
| FOREIGN_ KEY_ OPEN_PAR column_name (COMMA column_name)* CLOSE_PAR foreign_key_clause
)
;
foreign_key_clause:
REFERENCES_ foreign_table (
OPEN_PAR column_name (COMMA column_name)* CLOSE_PAR
)? (
ON_ (DELETE_ | UPDATE_) (
SET_ (NULL_ | DEFAULT_)
| CASCADE_
| RESTRICT_
| NO_ ACTION_
)
| MATCH_ name
)* (NOT_? DEFERRABLE_ (INITIALLY_ (DEFERRED_ | IMMEDIATE_))?)?
;
conflict_clause:
ON_ CONFLICT_ (
ROLLBACK_
| ABORT_
| FAIL_
| IGNORE_
| REPLACE_
)
;
create_trigger_stmt:
CREATE_ (TEMP_ | TEMPORARY_)? TRIGGER_ (IF_ NOT_ EXISTS_)? (
schema_name DOT
)? trigger_name (BEFORE_ | AFTER_ | INSTEAD_ OF_)? (
DELETE_
| INSERT_
| UPDATE_ (OF_ column_name ( COMMA column_name)*)?
) ON_ table_name (FOR_ EACH_ ROW_)? (WHEN_ expr)? BEGIN_ (
(update_stmt | insert_stmt | delete_stmt | select_stmt) SCOL
)+ END_
;
create_view_stmt:
CREATE_ (TEMP_ | TEMPORARY_)? VIEW_ (IF_ NOT_ EXISTS_)? (
schema_name DOT
)? view_name (OPEN_PAR column_name (COMMA column_name)* CLOSE_PAR)? AS_ select_stmt
;
create_virtual_table_stmt:
CREATE_ VIRTUAL_ TABLE_ (IF_ NOT_ EXISTS_)? (schema_name DOT)? table_name USING_ module_name (
OPEN_PAR module_argument (COMMA module_argument)* CLOSE_PAR
)?
;
with_clause:
WITH_ RECURSIVE_? cte_table_name AS_ OPEN_PAR select_stmt CLOSE_PAR (
COMMA cte_table_name AS_ OPEN_PAR select_stmt CLOSE_PAR
)*
;
cte_table_name:
table_name (OPEN_PAR column_name ( COMMA column_name)* CLOSE_PAR)?
;
recursive_cte:
cte_table_name AS_ OPEN_PAR initial_select UNION_ ALL_? recursive_select CLOSE_PAR
;
common_table_expression:
table_name (OPEN_PAR column_name ( COMMA column_name)* CLOSE_PAR)? AS_ OPEN_PAR select_stmt CLOSE_PAR
;
delete_stmt:
with_clause? DELETE_ FROM_ qualified_table_name (WHERE_ expr)? returning_clause?
;
delete_stmt_limited:
with_clause? DELETE_ FROM_ qualified_table_name (WHERE_ expr)? returning_clause? (
order_by_stmt? limit_stmt
)?
;
detach_stmt:
DETACH_ DATABASE_? schema_name
;
drop_stmt:
DROP_ object = (INDEX_ | TABLE_ | TRIGGER_ | VIEW_) (
IF_ EXISTS_
)? (schema_name DOT)? any_name
;
/*
SQLite understands the following binary operators, in order from highest to lowest precedence:
||
* / %
+ -
<< >> & |
< <= > >=
= == != <> IS IS NOT IN LIKE GLOB MATCH REGEXP
AND
OR
*/
expr:
literal_value
| BIND_PARAMETER
| ((schema_name DOT)? table_name DOT)? column_name
| unary_operator expr
| expr PIPE2 expr
| expr ( STAR | DIV | MOD) expr
| expr ( PLUS | MINUS) expr
| expr ( LT2 | GT2 | AMP | PIPE) expr
| expr ( LT | LT_EQ | GT | GT_EQ) expr
| expr (
ASSIGN
| EQ
| NOT_EQ1
| NOT_EQ2
| IS_
| IS_ NOT_
| IN_
| LIKE_
| GLOB_
| MATCH_
| REGEXP_
) expr
| expr AND_ expr
| expr OR_ expr
| function_name OPEN_PAR ((DISTINCT_? expr ( COMMA expr)*) | STAR)? CLOSE_PAR filter_clause? over_clause?
| OPEN_PAR expr (COMMA expr)* CLOSE_PAR
| CAST_ OPEN_PAR expr AS_ type_name CLOSE_PAR
| expr COLLATE_ collation_name
| expr NOT_? (LIKE_ | GLOB_ | REGEXP_ | MATCH_) expr (
ESCAPE_ expr
)?
| expr ( ISNULL_ | NOTNULL_ | NOT_ NULL_)
| expr IS_ NOT_? expr
| expr NOT_? BETWEEN_ expr AND_ expr
| expr NOT_? IN_ (
OPEN_PAR (select_stmt | expr ( COMMA expr)*)? CLOSE_PAR
| ( schema_name DOT)? table_name
| (schema_name DOT)? table_function_name OPEN_PAR (expr (COMMA expr)*)? CLOSE_PAR
)
| ((NOT_)? EXISTS_)? OPEN_PAR select_stmt CLOSE_PAR
| CASE_ expr? (WHEN_ expr THEN_ expr)+ (ELSE_ expr)? END_
| raise_function
;
raise_function:
RAISE_ OPEN_PAR (
IGNORE_
| (ROLLBACK_ | ABORT_ | FAIL_) COMMA error_message
) CLOSE_PAR
;
literal_value:
NUMERIC_LITERAL
| STRING_LITERAL
| BLOB_LITERAL
| NULL_
| TRUE_
| FALSE_
| CURRENT_TIME_
| CURRENT_DATE_
| CURRENT_TIMESTAMP_
;
insert_stmt:
with_clause? (
INSERT_
| REPLACE_
| INSERT_ OR_ (
REPLACE_
| ROLLBACK_
| ABORT_
| FAIL_
| IGNORE_
)
) INTO_ (schema_name DOT)? table_name (AS_ table_alias)? (
OPEN_PAR column_name ( COMMA column_name)* CLOSE_PAR
)? (
(
(
VALUES_ OPEN_PAR expr (COMMA expr)* CLOSE_PAR (
COMMA OPEN_PAR expr ( COMMA expr)* CLOSE_PAR
)*
| select_stmt
) upsert_clause?
)
| DEFAULT_ VALUES_
) returning_clause?
;
returning_clause:
RETURNING_ result_column (COMMA result_column)*
;
upsert_clause:
ON_ CONFLICT_ (
OPEN_PAR indexed_column (COMMA indexed_column)* CLOSE_PAR (WHERE_ expr)?
)? DO_ (
NOTHING_
| UPDATE_ SET_ (
(column_name | column_name_list) ASSIGN expr (
COMMA (column_name | column_name_list) ASSIGN expr
)* (WHERE_ expr)?
)
)
;
pragma_stmt:
PRAGMA_ (schema_name DOT)? pragma_name (
ASSIGN pragma_value
| OPEN_PAR pragma_value CLOSE_PAR
)?
;
pragma_value:
signed_number
| name
| STRING_LITERAL
;
reindex_stmt:
REINDEX_ (collation_name | (schema_name DOT)? (table_name | index_name))?
;
select_stmt:
common_table_stmt? select_core (compound_operator select_core)* order_by_stmt? limit_stmt?
;
join_clause:
table_or_subquery (join_operator table_or_subquery join_constraint?)*
;
select_core:
(
SELECT_ (DISTINCT_ | ALL_)? result_column (COMMA result_column)* (
FROM_ (table_or_subquery (COMMA table_or_subquery)* | join_clause)
)? (WHERE_ expr)? (GROUP_ BY_ expr (COMMA expr)* (HAVING_ expr)?)? (
WINDOW_ window_name AS_ window_defn (
COMMA window_name AS_ window_defn
)*
)?
)
| VALUES_ OPEN_PAR expr (COMMA expr)* CLOSE_PAR (
COMMA OPEN_PAR expr ( COMMA expr)* CLOSE_PAR
)*
;
factored_select_stmt:
select_stmt
;
simple_select_stmt:
common_table_stmt? select_core order_by_stmt? limit_stmt?
;
compound_select_stmt:
common_table_stmt? select_core (
(UNION_ ALL_? | INTERSECT_ | EXCEPT_) select_core
)+ order_by_stmt? limit_stmt?
;
table_or_subquery: (
(schema_name DOT)? table_name (AS_? table_alias)? (
INDEXED_ BY_ index_name
| NOT_ INDEXED_
)?
)
| (schema_name DOT)? table_function_name OPEN_PAR expr (COMMA expr)* CLOSE_PAR (
AS_? table_alias
)?
| OPEN_PAR (table_or_subquery (COMMA table_or_subquery)* | join_clause) CLOSE_PAR
| OPEN_PAR select_stmt CLOSE_PAR (AS_? table_alias)?
;
result_column:
STAR
| table_name DOT STAR
| expr ( AS_? column_alias)?
;
join_operator:
COMMA
| NATURAL_? (LEFT_ OUTER_? | INNER_ | CROSS_)? JOIN_
;
join_constraint:
ON_ expr
| USING_ OPEN_PAR column_name ( COMMA column_name)* CLOSE_PAR
;
compound_operator:
UNION_ ALL_?
| INTERSECT_
| EXCEPT_
;
update_stmt:
with_clause? UPDATE_ (
OR_ (ROLLBACK_ | ABORT_ | REPLACE_ | FAIL_ | IGNORE_)
)? qualified_table_name SET_ assignment_list (
FROM_ (table_or_subquery (COMMA table_or_subquery)* | join_clause)
)? (WHERE_ where = expr)? returning_clause?
;
assignment_list:
assignment
(COMMA assignment)*
;
assignment:
(column_name | column_name_list) ASSIGN expr
;
column_name_list:
OPEN_PAR column_name (COMMA column_name)* CLOSE_PAR
;
update_stmt_limited:
with_clause? UPDATE_ (
OR_ (ROLLBACK_ | ABORT_ | REPLACE_ | FAIL_ | IGNORE_)
)? qualified_table_name SET_ (column_name | column_name_list) ASSIGN expr (
COMMA (column_name | column_name_list) ASSIGN expr
)* (WHERE_ expr)? returning_clause? (order_by_stmt? limit_stmt)?
;
qualified_table_name: (schema_name DOT)? table_name (AS_ alias)? (
INDEXED_ BY_ index_name
| NOT_ INDEXED_
)?
;
vacuum_stmt:
VACUUM_ schema_name? (INTO_ filename)?
;
filter_clause:
FILTER_ OPEN_PAR WHERE_ expr CLOSE_PAR
;
window_defn:
OPEN_PAR base_window_name? (PARTITION_ BY_ expr (COMMA expr)*)? (
ORDER_ BY_ ordering_term (COMMA ordering_term)*
) frame_spec? CLOSE_PAR
;
over_clause:
OVER_ (
window_name
| OPEN_PAR base_window_name? (PARTITION_ BY_ expr (COMMA expr)*)? (
ORDER_ BY_ ordering_term (COMMA ordering_term)*
)? frame_spec? CLOSE_PAR
)
;
frame_spec:
frame_clause (
EXCLUDE_ (NO_ OTHERS_)
| CURRENT_ ROW_
| GROUP_
| TIES_
)?
;
frame_clause: (RANGE_ | ROWS_ | GROUPS_) (
frame_single
| BETWEEN_ frame_left AND_ frame_right
)
;
simple_function_invocation:
simple_func OPEN_PAR (expr (COMMA expr)* | STAR) CLOSE_PAR
;
aggregate_function_invocation:
aggregate_func OPEN_PAR (DISTINCT_? expr (COMMA expr)* | STAR)? CLOSE_PAR filter_clause?
;
window_function_invocation:
window_function OPEN_PAR (expr (COMMA expr)* | STAR)? CLOSE_PAR filter_clause? OVER_ (
window_defn
| window_name
)
;
common_table_stmt: //additional structures
WITH_ RECURSIVE_? common_table_expression (COMMA common_table_expression)*
;
order_by_stmt:
ORDER_ BY_ ordering_term (COMMA ordering_term)*
;
limit_stmt:
LIMIT_ expr ((OFFSET_ | COMMA) expr)?
;
ordering_term:
expr (COLLATE_ collation_name)? asc_desc? (NULLS_ (FIRST_ | LAST_))?
;
asc_desc:
ASC_
| DESC_
;
frame_left:
expr PRECEDING_
| expr FOLLOWING_
| CURRENT_ ROW_
| UNBOUNDED_ PRECEDING_
;
frame_right:
expr PRECEDING_
| expr FOLLOWING_
| CURRENT_ ROW_
| UNBOUNDED_ FOLLOWING_
;
frame_single:
expr PRECEDING_
| UNBOUNDED_ PRECEDING_
| CURRENT_ ROW_
;
// unknown
window_function:
(FIRST_VALUE_ | LAST_VALUE_) OPEN_PAR expr CLOSE_PAR OVER_ OPEN_PAR partition_by? order_by_expr_asc_desc frame_clause
? CLOSE_PAR
| (CUME_DIST_ | PERCENT_RANK_) OPEN_PAR CLOSE_PAR OVER_ OPEN_PAR partition_by? order_by_expr? CLOSE_PAR
| (DENSE_RANK_ | RANK_ | ROW_NUMBER_) OPEN_PAR CLOSE_PAR OVER_ OPEN_PAR partition_by? order_by_expr_asc_desc
CLOSE_PAR
| (LAG_ | LEAD_) OPEN_PAR expr offset? default_value? CLOSE_PAR OVER_ OPEN_PAR partition_by?
order_by_expr_asc_desc CLOSE_PAR
| NTH_VALUE_ OPEN_PAR expr COMMA signed_number CLOSE_PAR OVER_ OPEN_PAR partition_by? order_by_expr_asc_desc
frame_clause? CLOSE_PAR
| NTILE_ OPEN_PAR expr CLOSE_PAR OVER_ OPEN_PAR partition_by? order_by_expr_asc_desc CLOSE_PAR
;
offset:
COMMA signed_number
;
default_value:
COMMA signed_number
;
partition_by:
PARTITION_ BY_ expr+
;
order_by_expr:
ORDER_ BY_ expr+
;
order_by_expr_asc_desc:
ORDER_ BY_ expr_asc_desc
;
expr_asc_desc:
expr asc_desc? (COMMA expr asc_desc?)*
;
//TODO BOTH OF THESE HAVE TO BE REWORKED TO FOLLOW THE SPEC
initial_select:
select_stmt
;
recursive_select:
select_stmt
;
unary_operator:
MINUS
| PLUS
| TILDE
| NOT_
;
error_message:
STRING_LITERAL
;
module_argument: // TODO check what exactly is permitted here
expr
| column_def
;
column_alias:
IDENTIFIER
| STRING_LITERAL
;
keyword:
ABORT_
| ACTION_
| ADD_
| AFTER_
| ALL_
| ALTER_
| ANALYZE_
| AND_
| AS_
| ASC_
| ATTACH_
| AUTOINCREMENT_
| BEFORE_
| BEGIN_
| BETWEEN_
| BY_
| CASCADE_
| CASE_
| CAST_
| CHECK_
| COLLATE_
| COLUMN_
| COMMIT_
| CONFLICT_
| CONSTRAINT_
| CREATE_
| CROSS_
| CURRENT_DATE_
| CURRENT_TIME_
| CURRENT_TIMESTAMP_
| DATABASE_
| DEFAULT_
| DEFERRABLE_
| DEFERRED_
| DELETE_
| DESC_
| DETACH_
| DISTINCT_
| DROP_
| EACH_
| ELSE_
| END_
| ESCAPE_
| EXCEPT_
| EXCLUSIVE_
| EXISTS_
| EXPLAIN_
| FAIL_
| FOR_
| FOREIGN_
| FROM_
| FULL_
| GLOB_
| GROUP_
| HAVING_
| IF_
| IGNORE_
| IMMEDIATE_
| IN_
| INDEX_
| INDEXED_
| INITIALLY_
| INNER_
| INSERT_
| INSTEAD_
| INTERSECT_
| INTO_
| IS_
| ISNULL_
| JOIN_
| KEY_
| LEFT_
| LIKE_
| LIMIT_
| MATCH_
| NATURAL_
| NO_
| NOT_
| NOTNULL_
| NULL_
| OF_
| OFFSET_
| ON_
| OR_
| ORDER_
| OUTER_
| PLAN_
| PRAGMA_
| PRIMARY_
| QUERY_
| RAISE_
| RECURSIVE_
| REFERENCES_
| REGEXP_
| REINDEX_
| RELEASE_
| RENAME_
| REPLACE_
| RESTRICT_
| RIGHT_
| ROLLBACK_
| ROW_
| ROWS_
| SAVEPOINT_
| SELECT_
| SET_
| TABLE_
| TEMP_
| TEMPORARY_
| THEN_
| TO_
| TRANSACTION_
| TRIGGER_
| UNION_
| UNIQUE_
| UPDATE_
| USING_
| VACUUM_
| VALUES_
| VIEW_
| VIRTUAL_
| WHEN_
| WHERE_
| WITH_
| WITHOUT_
| FIRST_VALUE_
| OVER_
| PARTITION_
| RANGE_
| PRECEDING_
| UNBOUNDED_
| CURRENT_
| FOLLOWING_
| CUME_DIST_
| DENSE_RANK_
| LAG_
| LAST_VALUE_
| LEAD_
| NTH_VALUE_
| NTILE_
| PERCENT_RANK_
| RANK_
| ROW_NUMBER_
| GENERATED_
| ALWAYS_
| STORED_
| TRUE_
| FALSE_
| WINDOW_
| NULLS_
| FIRST_
| LAST_
| FILTER_
| GROUPS_
| EXCLUDE_
;
// TODO: check all names below
name:
any_name
;
function_name:
any_name
;
schema_name:
any_name
;
table_name:
any_name
;
table_or_index_name:
any_name
;
column_name:
any_name
;
collation_name:
any_name
;
foreign_table:
any_name
;
index_name:
any_name
;
trigger_name:
any_name
;
view_name:
any_name
;
module_name:
any_name
;
pragma_name:
any_name
;
savepoint_name:
any_name
;
table_alias:
any_name
;
transaction_name:
any_name
;
window_name:
any_name
;
alias:
any_name
;
filename:
any_name
;
base_window_name:
any_name
;
simple_func:
any_name
;
aggregate_func:
any_name
;
table_function_name:
any_name
;
any_name:
IDENTIFIER
| keyword
| STRING_LITERAL
| OPEN_PAR any_name CLOSE_PAR
;
atlas-0.7.2/cmd/atlas/internal/sqlparse/sqliteparse/README.md 0000664 0000000 0000000 00000000736 14314555116 0023767 0 ustar 00root root 0000000 0000000 ### SQLite parser based on ANTLR4
#### Resources
1. SQLite syntax: https://www.sqlite.org/syntaxdiagrams.html
2. Grammar file: https://github.com/antlr/grammars-v4/tree/master/sql/sqlite
#### Run codegen
1. Install `antlr4`: https://github.com/antlr/antlr4/blob/master/doc/getting-started.md#unix
2. Run:
```bash
antlr4 -Dlanguage=Go -package sqliteparse -visitor Lexer.g4 Parser.g4 \
&& mv _lexer.go lexer.go \
&& mv _parser.go parser.go \
&& rm *.interp *.tokens
``` atlas-0.7.2/cmd/atlas/internal/sqlparse/sqliteparse/lexer.go 0000664 0000000 0000000 00000214640 14314555116 0024157 0 ustar 00root root 0000000 0000000 // Code generated from Lexer.g4 by ANTLR 4.10.1. DO NOT EDIT.
package sqliteparse
import (
"fmt"
"sync"
"unicode"
"github.com/antlr/antlr4/runtime/Go/antlr"
)
// Suppress unused import error
var _ = fmt.Printf
var _ = sync.Once{}
var _ = unicode.IsLetter
type Lexer struct {
*antlr.BaseLexer
channelNames []string
modeNames []string
// TODO: EOF string
}
var lexerLexerStaticData struct {
once sync.Once
serializedATN []int32
channelNames []string
modeNames []string
literalNames []string
symbolicNames []string
ruleNames []string
predictionContextCache *antlr.PredictionContextCache
atn *antlr.ATN
decisionToDFA []*antlr.DFA
}
func lexerLexerInit() {
staticData := &lexerLexerStaticData
staticData.channelNames = []string{
"DEFAULT_TOKEN_CHANNEL", "HIDDEN",
}
staticData.modeNames = []string{
"DEFAULT_MODE",
}
staticData.literalNames = []string{
"", "';'", "'.'", "'('", "')'", "','", "'='", "'*'", "'+'", "'-'", "'~'",
"'||'", "'/'", "'%'", "'<<'", "'>>'", "'&'", "'|'", "'<'", "'<='", "'>'",
"'>='", "'=='", "'!='", "'<>'", "'ABORT'", "'ACTION'", "'ADD'", "'AFTER'",
"'ALL'", "'ALTER'", "'ANALYZE'", "'AND'", "'AS'", "'ASC'", "'ATTACH'",
"'AUTOINCREMENT'", "'BEFORE'", "'BEGIN'", "'BETWEEN'", "'BY'", "'CASCADE'",
"'CASE'", "'CAST'", "'CHECK'", "'COLLATE'", "'COLUMN'", "'COMMIT'",
"'CONFLICT'", "'CONSTRAINT'", "'CREATE'", "'CROSS'", "'CURRENT_DATE'",
"'CURRENT_TIME'", "'CURRENT_TIMESTAMP'", "'DATABASE'", "'DEFAULT'",
"'DEFERRABLE'", "'DEFERRED'", "'DELETE'", "'DESC'", "'DETACH'", "'DISTINCT'",
"'DROP'", "'EACH'", "'ELSE'", "'END'", "'ESCAPE'", "'EXCEPT'", "'EXCLUSIVE'",
"'EXISTS'", "'EXPLAIN'", "'FAIL'", "'FOR'", "'FOREIGN'", "'FROM'", "'FULL'",
"'GLOB'", "'GROUP'", "'HAVING'", "'IF'", "'IGNORE'", "'IMMEDIATE'",
"'IN'", "'INDEX'", "'INDEXED'", "'INITIALLY'", "'INNER'", "'INSERT'",
"'INSTEAD'", "'INTERSECT'", "'INTO'", "'IS'", "'ISNULL'", "'JOIN'",
"'KEY'", "'LEFT'", "'LIKE'", "'LIMIT'", "'MATCH'", "'NATURAL'", "'NO'",
"'NOT'", "'NOTNULL'", "'NULL'", "'OF'", "'OFFSET'", "'ON'", "'OR'",
"'ORDER'", "'OUTER'", "'PLAN'", "'PRAGMA'", "'PRIMARY'", "'QUERY'",
"'RAISE'", "'RECURSIVE'", "'REFERENCES'", "'REGEXP'", "'REINDEX'", "'RELEASE'",
"'RENAME'", "'REPLACE'", "'RESTRICT'", "'RETURNING'", "'RIGHT'", "'ROLLBACK'",
"'ROW'", "'ROWS'", "'SAVEPOINT'", "'SELECT'", "'SET'", "'TABLE'", "'TEMP'",
"'TEMPORARY'", "'THEN'", "'TO'", "'TRANSACTION'", "'TRIGGER'", "'UNION'",
"'UNIQUE'", "'UPDATE'", "'USING'", "'VACUUM'", "'VALUES'", "'VIEW'",
"'VIRTUAL'", "'WHEN'", "'WHERE'", "'WITH'", "'WITHOUT'", "'FIRST_VALUE'",
"'OVER'", "'PARTITION'", "'RANGE'", "'PRECEDING'", "'UNBOUNDED'", "'CURRENT'",
"'FOLLOWING'", "'CUME_DIST'", "'DENSE_RANK'", "'LAG'", "'LAST_VALUE'",
"'LEAD'", "'NTH_VALUE'", "'NTILE'", "'PERCENT_RANK'", "'RANK'", "'ROW_NUMBER'",
"'GENERATED'", "'ALWAYS'", "'STORED'", "'TRUE'", "'FALSE'", "'WINDOW'",
"'NULLS'", "'FIRST'", "'LAST'", "'FILTER'", "'GROUPS'", "'EXCLUDE'",
"'TIES'", "'OTHERS'", "'DO'", "'NOTHING'",
}
staticData.symbolicNames = []string{
"", "SCOL", "DOT", "OPEN_PAR", "CLOSE_PAR", "COMMA", "ASSIGN", "STAR",
"PLUS", "MINUS", "TILDE", "PIPE2", "DIV", "MOD", "LT2", "GT2", "AMP",
"PIPE", "LT", "LT_EQ", "GT", "GT_EQ", "EQ", "NOT_EQ1", "NOT_EQ2", "ABORT_",
"ACTION_", "ADD_", "AFTER_", "ALL_", "ALTER_", "ANALYZE_", "AND_", "AS_",
"ASC_", "ATTACH_", "AUTOINCREMENT_", "BEFORE_", "BEGIN_", "BETWEEN_",
"BY_", "CASCADE_", "CASE_", "CAST_", "CHECK_", "COLLATE_", "COLUMN_",
"COMMIT_", "CONFLICT_", "CONSTRAINT_", "CREATE_", "CROSS_", "CURRENT_DATE_",
"CURRENT_TIME_", "CURRENT_TIMESTAMP_", "DATABASE_", "DEFAULT_", "DEFERRABLE_",
"DEFERRED_", "DELETE_", "DESC_", "DETACH_", "DISTINCT_", "DROP_", "EACH_",
"ELSE_", "END_", "ESCAPE_", "EXCEPT_", "EXCLUSIVE_", "EXISTS_", "EXPLAIN_",
"FAIL_", "FOR_", "FOREIGN_", "FROM_", "FULL_", "GLOB_", "GROUP_", "HAVING_",
"IF_", "IGNORE_", "IMMEDIATE_", "IN_", "INDEX_", "INDEXED_", "INITIALLY_",
"INNER_", "INSERT_", "INSTEAD_", "INTERSECT_", "INTO_", "IS_", "ISNULL_",
"JOIN_", "KEY_", "LEFT_", "LIKE_", "LIMIT_", "MATCH_", "NATURAL_", "NO_",
"NOT_", "NOTNULL_", "NULL_", "OF_", "OFFSET_", "ON_", "OR_", "ORDER_",
"OUTER_", "PLAN_", "PRAGMA_", "PRIMARY_", "QUERY_", "RAISE_", "RECURSIVE_",
"REFERENCES_", "REGEXP_", "REINDEX_", "RELEASE_", "RENAME_", "REPLACE_",
"RESTRICT_", "RETURNING_", "RIGHT_", "ROLLBACK_", "ROW_", "ROWS_", "SAVEPOINT_",
"SELECT_", "SET_", "TABLE_", "TEMP_", "TEMPORARY_", "THEN_", "TO_",
"TRANSACTION_", "TRIGGER_", "UNION_", "UNIQUE_", "UPDATE_", "USING_",
"VACUUM_", "VALUES_", "VIEW_", "VIRTUAL_", "WHEN_", "WHERE_", "WITH_",
"WITHOUT_", "FIRST_VALUE_", "OVER_", "PARTITION_", "RANGE_", "PRECEDING_",
"UNBOUNDED_", "CURRENT_", "FOLLOWING_", "CUME_DIST_", "DENSE_RANK_",
"LAG_", "LAST_VALUE_", "LEAD_", "NTH_VALUE_", "NTILE_", "PERCENT_RANK_",
"RANK_", "ROW_NUMBER_", "GENERATED_", "ALWAYS_", "STORED_", "TRUE_",
"FALSE_", "WINDOW_", "NULLS_", "FIRST_", "LAST_", "FILTER_", "GROUPS_",
"EXCLUDE_", "TIES_", "OTHERS_", "DO_", "NOTHING_", "IDENTIFIER", "NUMERIC_LITERAL",
"BIND_PARAMETER", "STRING_LITERAL", "BLOB_LITERAL", "SINGLE_LINE_COMMENT",
"MULTILINE_COMMENT", "SPACES", "UNEXPECTED_CHAR",
}
staticData.ruleNames = []string{
"SCOL", "DOT", "OPEN_PAR", "CLOSE_PAR", "COMMA", "ASSIGN", "STAR", "PLUS",
"MINUS", "TILDE", "PIPE2", "DIV", "MOD", "LT2", "GT2", "AMP", "PIPE",
"LT", "LT_EQ", "GT", "GT_EQ", "EQ", "NOT_EQ1", "NOT_EQ2", "ABORT_",
"ACTION_", "ADD_", "AFTER_", "ALL_", "ALTER_", "ANALYZE_", "AND_", "AS_",
"ASC_", "ATTACH_", "AUTOINCREMENT_", "BEFORE_", "BEGIN_", "BETWEEN_",
"BY_", "CASCADE_", "CASE_", "CAST_", "CHECK_", "COLLATE_", "COLUMN_",
"COMMIT_", "CONFLICT_", "CONSTRAINT_", "CREATE_", "CROSS_", "CURRENT_DATE_",
"CURRENT_TIME_", "CURRENT_TIMESTAMP_", "DATABASE_", "DEFAULT_", "DEFERRABLE_",
"DEFERRED_", "DELETE_", "DESC_", "DETACH_", "DISTINCT_", "DROP_", "EACH_",
"ELSE_", "END_", "ESCAPE_", "EXCEPT_", "EXCLUSIVE_", "EXISTS_", "EXPLAIN_",
"FAIL_", "FOR_", "FOREIGN_", "FROM_", "FULL_", "GLOB_", "GROUP_", "HAVING_",
"IF_", "IGNORE_", "IMMEDIATE_", "IN_", "INDEX_", "INDEXED_", "INITIALLY_",
"INNER_", "INSERT_", "INSTEAD_", "INTERSECT_", "INTO_", "IS_", "ISNULL_",
"JOIN_", "KEY_", "LEFT_", "LIKE_", "LIMIT_", "MATCH_", "NATURAL_", "NO_",
"NOT_", "NOTNULL_", "NULL_", "OF_", "OFFSET_", "ON_", "OR_", "ORDER_",
"OUTER_", "PLAN_", "PRAGMA_", "PRIMARY_", "QUERY_", "RAISE_", "RECURSIVE_",
"REFERENCES_", "REGEXP_", "REINDEX_", "RELEASE_", "RENAME_", "REPLACE_",
"RESTRICT_", "RETURNING_", "RIGHT_", "ROLLBACK_", "ROW_", "ROWS_", "SAVEPOINT_",
"SELECT_", "SET_", "TABLE_", "TEMP_", "TEMPORARY_", "THEN_", "TO_",
"TRANSACTION_", "TRIGGER_", "UNION_", "UNIQUE_", "UPDATE_", "USING_",
"VACUUM_", "VALUES_", "VIEW_", "VIRTUAL_", "WHEN_", "WHERE_", "WITH_",
"WITHOUT_", "FIRST_VALUE_", "OVER_", "PARTITION_", "RANGE_", "PRECEDING_",
"UNBOUNDED_", "CURRENT_", "FOLLOWING_", "CUME_DIST_", "DENSE_RANK_",
"LAG_", "LAST_VALUE_", "LEAD_", "NTH_VALUE_", "NTILE_", "PERCENT_RANK_",
"RANK_", "ROW_NUMBER_", "GENERATED_", "ALWAYS_", "STORED_", "TRUE_",
"FALSE_", "WINDOW_", "NULLS_", "FIRST_", "LAST_", "FILTER_", "GROUPS_",
"EXCLUDE_", "TIES_", "OTHERS_", "DO_", "NOTHING_", "IDENTIFIER", "NUMERIC_LITERAL",
"BIND_PARAMETER", "STRING_LITERAL", "BLOB_LITERAL", "SINGLE_LINE_COMMENT",
"MULTILINE_COMMENT", "SPACES", "UNEXPECTED_CHAR", "HEX_DIGIT", "DIGIT",
}
staticData.predictionContextCache = antlr.NewPredictionContextCache()
staticData.serializedATN = []int32{
4, 0, 193, 1704, 6, -1, 2, 0, 7, 0, 2, 1, 7, 1, 2, 2, 7, 2, 2, 3, 7, 3,
2, 4, 7, 4, 2, 5, 7, 5, 2, 6, 7, 6, 2, 7, 7, 7, 2, 8, 7, 8, 2, 9, 7, 9,
2, 10, 7, 10, 2, 11, 7, 11, 2, 12, 7, 12, 2, 13, 7, 13, 2, 14, 7, 14, 2,
15, 7, 15, 2, 16, 7, 16, 2, 17, 7, 17, 2, 18, 7, 18, 2, 19, 7, 19, 2, 20,
7, 20, 2, 21, 7, 21, 2, 22, 7, 22, 2, 23, 7, 23, 2, 24, 7, 24, 2, 25, 7,
25, 2, 26, 7, 26, 2, 27, 7, 27, 2, 28, 7, 28, 2, 29, 7, 29, 2, 30, 7, 30,
2, 31, 7, 31, 2, 32, 7, 32, 2, 33, 7, 33, 2, 34, 7, 34, 2, 35, 7, 35, 2,
36, 7, 36, 2, 37, 7, 37, 2, 38, 7, 38, 2, 39, 7, 39, 2, 40, 7, 40, 2, 41,
7, 41, 2, 42, 7, 42, 2, 43, 7, 43, 2, 44, 7, 44, 2, 45, 7, 45, 2, 46, 7,
46, 2, 47, 7, 47, 2, 48, 7, 48, 2, 49, 7, 49, 2, 50, 7, 50, 2, 51, 7, 51,
2, 52, 7, 52, 2, 53, 7, 53, 2, 54, 7, 54, 2, 55, 7, 55, 2, 56, 7, 56, 2,
57, 7, 57, 2, 58, 7, 58, 2, 59, 7, 59, 2, 60, 7, 60, 2, 61, 7, 61, 2, 62,
7, 62, 2, 63, 7, 63, 2, 64, 7, 64, 2, 65, 7, 65, 2, 66, 7, 66, 2, 67, 7,
67, 2, 68, 7, 68, 2, 69, 7, 69, 2, 70, 7, 70, 2, 71, 7, 71, 2, 72, 7, 72,
2, 73, 7, 73, 2, 74, 7, 74, 2, 75, 7, 75, 2, 76, 7, 76, 2, 77, 7, 77, 2,
78, 7, 78, 2, 79, 7, 79, 2, 80, 7, 80, 2, 81, 7, 81, 2, 82, 7, 82, 2, 83,
7, 83, 2, 84, 7, 84, 2, 85, 7, 85, 2, 86, 7, 86, 2, 87, 7, 87, 2, 88, 7,
88, 2, 89, 7, 89, 2, 90, 7, 90, 2, 91, 7, 91, 2, 92, 7, 92, 2, 93, 7, 93,
2, 94, 7, 94, 2, 95, 7, 95, 2, 96, 7, 96, 2, 97, 7, 97, 2, 98, 7, 98, 2,
99, 7, 99, 2, 100, 7, 100, 2, 101, 7, 101, 2, 102, 7, 102, 2, 103, 7, 103,
2, 104, 7, 104, 2, 105, 7, 105, 2, 106, 7, 106, 2, 107, 7, 107, 2, 108,
7, 108, 2, 109, 7, 109, 2, 110, 7, 110, 2, 111, 7, 111, 2, 112, 7, 112,
2, 113, 7, 113, 2, 114, 7, 114, 2, 115, 7, 115, 2, 116, 7, 116, 2, 117,
7, 117, 2, 118, 7, 118, 2, 119, 7, 119, 2, 120, 7, 120, 2, 121, 7, 121,
2, 122, 7, 122, 2, 123, 7, 123, 2, 124, 7, 124, 2, 125, 7, 125, 2, 126,
7, 126, 2, 127, 7, 127, 2, 128, 7, 128, 2, 129, 7, 129, 2, 130, 7, 130,
2, 131, 7, 131, 2, 132, 7, 132, 2, 133, 7, 133, 2, 134, 7, 134, 2, 135,
7, 135, 2, 136, 7, 136, 2, 137, 7, 137, 2, 138, 7, 138, 2, 139, 7, 139,
2, 140, 7, 140, 2, 141, 7, 141, 2, 142, 7, 142, 2, 143, 7, 143, 2, 144,
7, 144, 2, 145, 7, 145, 2, 146, 7, 146, 2, 147, 7, 147, 2, 148, 7, 148,
2, 149, 7, 149, 2, 150, 7, 150, 2, 151, 7, 151, 2, 152, 7, 152, 2, 153,
7, 153, 2, 154, 7, 154, 2, 155, 7, 155, 2, 156, 7, 156, 2, 157, 7, 157,
2, 158, 7, 158, 2, 159, 7, 159, 2, 160, 7, 160, 2, 161, 7, 161, 2, 162,
7, 162, 2, 163, 7, 163, 2, 164, 7, 164, 2, 165, 7, 165, 2, 166, 7, 166,
2, 167, 7, 167, 2, 168, 7, 168, 2, 169, 7, 169, 2, 170, 7, 170, 2, 171,
7, 171, 2, 172, 7, 172, 2, 173, 7, 173, 2, 174, 7, 174, 2, 175, 7, 175,
2, 176, 7, 176, 2, 177, 7, 177, 2, 178, 7, 178, 2, 179, 7, 179, 2, 180,
7, 180, 2, 181, 7, 181, 2, 182, 7, 182, 2, 183, 7, 183, 2, 184, 7, 184,
2, 185, 7, 185, 2, 186, 7, 186, 2, 187, 7, 187, 2, 188, 7, 188, 2, 189,
7, 189, 2, 190, 7, 190, 2, 191, 7, 191, 2, 192, 7, 192, 2, 193, 7, 193,
2, 194, 7, 194, 1, 0, 1, 0, 1, 1, 1, 1, 1, 2, 1, 2, 1, 3, 1, 3, 1, 4, 1,
4, 1, 5, 1, 5, 1, 6, 1, 6, 1, 7, 1, 7, 1, 8, 1, 8, 1, 9, 1, 9, 1, 10, 1,
10, 1, 10, 1, 11, 1, 11, 1, 12, 1, 12, 1, 13, 1, 13, 1, 13, 1, 14, 1, 14,
1, 14, 1, 15, 1, 15, 1, 16, 1, 16, 1, 17, 1, 17, 1, 18, 1, 18, 1, 18, 1,
19, 1, 19, 1, 20, 1, 20, 1, 20, 1, 21, 1, 21, 1, 21, 1, 22, 1, 22, 1, 22,
1, 23, 1, 23, 1, 23, 1, 24, 1, 24, 1, 24, 1, 24, 1, 24, 1, 24, 1, 25, 1,
25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 1, 26, 1, 26, 1, 26, 1, 26, 1, 27,
1, 27, 1, 27, 1, 27, 1, 27, 1, 27, 1, 28, 1, 28, 1, 28, 1, 28, 1, 29, 1,
29, 1, 29, 1, 29, 1, 29, 1, 29, 1, 30, 1, 30, 1, 30, 1, 30, 1, 30, 1, 30,
1, 30, 1, 30, 1, 31, 1, 31, 1, 31, 1, 31, 1, 32, 1, 32, 1, 32, 1, 33, 1,
33, 1, 33, 1, 33, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 34, 1, 35,
1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1,
35, 1, 35, 1, 35, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 36, 1, 37,
1, 37, 1, 37, 1, 37, 1, 37, 1, 37, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1,
38, 1, 38, 1, 38, 1, 39, 1, 39, 1, 39, 1, 40, 1, 40, 1, 40, 1, 40, 1, 40,
1, 40, 1, 40, 1, 40, 1, 41, 1, 41, 1, 41, 1, 41, 1, 41, 1, 42, 1, 42, 1,
42, 1, 42, 1, 42, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 44, 1, 44,
1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 44, 1, 45, 1, 45, 1, 45, 1, 45, 1,
45, 1, 45, 1, 45, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 46, 1, 47,
1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 48, 1, 48, 1,
48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 48, 1, 49, 1, 49,
1, 49, 1, 49, 1, 49, 1, 49, 1, 49, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1,
50, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51, 1, 51,
1, 51, 1, 51, 1, 51, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1,
52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 52, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53,
1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1, 53, 1,
53, 1, 53, 1, 53, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54, 1, 54,
1, 54, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 55, 1, 56, 1,
56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 57,
1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 58, 1, 58, 1,
58, 1, 58, 1, 58, 1, 58, 1, 58, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 60,
1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 61, 1, 61, 1, 61, 1, 61, 1,
61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 1, 63,
1, 63, 1, 63, 1, 63, 1, 63, 1, 64, 1, 64, 1, 64, 1, 64, 1, 64, 1, 65, 1,
65, 1, 65, 1, 65, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 66, 1, 67,
1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, 67, 1, 68, 1, 68, 1, 68, 1, 68, 1,
68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 68, 1, 69, 1, 69, 1, 69, 1, 69, 1, 69,
1, 69, 1, 69, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 1, 70, 1,
71, 1, 71, 1, 71, 1, 71, 1, 71, 1, 72, 1, 72, 1, 72, 1, 72, 1, 73, 1, 73,
1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 74, 1, 74, 1, 74, 1, 74, 1,
74, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 76, 1, 76, 1, 76, 1, 76, 1, 76,
1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 77, 1, 78, 1, 78, 1, 78, 1, 78, 1,
78, 1, 78, 1, 78, 1, 79, 1, 79, 1, 79, 1, 80, 1, 80, 1, 80, 1, 80, 1, 80,
1, 80, 1, 80, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1, 81, 1,
81, 1, 81, 1, 82, 1, 82, 1, 82, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83, 1, 83,
1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 84, 1, 85, 1, 85, 1,
85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 85, 1, 86, 1, 86, 1, 86,
1, 86, 1, 86, 1, 86, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1, 87, 1,
88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 88, 1, 89, 1, 89, 1, 89,
1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 89, 1, 90, 1, 90, 1, 90, 1,
90, 1, 90, 1, 91, 1, 91, 1, 91, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92, 1, 92,
1, 92, 1, 93, 1, 93, 1, 93, 1, 93, 1, 93, 1, 94, 1, 94, 1, 94, 1, 94, 1,
95, 1, 95, 1, 95, 1, 95, 1, 95, 1, 96, 1, 96, 1, 96, 1, 96, 1, 96, 1, 97,
1, 97, 1, 97, 1, 97, 1, 97, 1, 97, 1, 98, 1, 98, 1, 98, 1, 98, 1, 98, 1,
98, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 99, 1, 100, 1,
100, 1, 100, 1, 101, 1, 101, 1, 101, 1, 101, 1, 102, 1, 102, 1, 102, 1,
102, 1, 102, 1, 102, 1, 102, 1, 102, 1, 103, 1, 103, 1, 103, 1, 103, 1,
103, 1, 104, 1, 104, 1, 104, 1, 105, 1, 105, 1, 105, 1, 105, 1, 105, 1,
105, 1, 105, 1, 106, 1, 106, 1, 106, 1, 107, 1, 107, 1, 107, 1, 108, 1,
108, 1, 108, 1, 108, 1, 108, 1, 108, 1, 109, 1, 109, 1, 109, 1, 109, 1,
109, 1, 109, 1, 110, 1, 110, 1, 110, 1, 110, 1, 110, 1, 111, 1, 111, 1,
111, 1, 111, 1, 111, 1, 111, 1, 111, 1, 112, 1, 112, 1, 112, 1, 112, 1,
112, 1, 112, 1, 112, 1, 112, 1, 113, 1, 113, 1, 113, 1, 113, 1, 113, 1,
113, 1, 114, 1, 114, 1, 114, 1, 114, 1, 114, 1, 114, 1, 115, 1, 115, 1,
115, 1, 115, 1, 115, 1, 115, 1, 115, 1, 115, 1, 115, 1, 115, 1, 116, 1,
116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1, 116, 1,
116, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 117, 1, 118, 1,
118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 118, 1, 119, 1, 119, 1,
119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 119, 1, 120, 1, 120, 1, 120, 1,
120, 1, 120, 1, 120, 1, 120, 1, 121, 1, 121, 1, 121, 1, 121, 1, 121, 1,
121, 1, 121, 1, 121, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1, 122, 1,
122, 1, 122, 1, 122, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1, 123, 1,
123, 1, 123, 1, 123, 1, 123, 1, 124, 1, 124, 1, 124, 1, 124, 1, 124, 1,
124, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1, 125, 1,
125, 1, 126, 1, 126, 1, 126, 1, 126, 1, 127, 1, 127, 1, 127, 1, 127, 1,
127, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1, 128, 1,
128, 1, 128, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1, 129, 1,
130, 1, 130, 1, 130, 1, 130, 1, 131, 1, 131, 1, 131, 1, 131, 1, 131, 1,
131, 1, 132, 1, 132, 1, 132, 1, 132, 1, 132, 1, 133, 1, 133, 1, 133, 1,
133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 133, 1, 134, 1, 134, 1,
134, 1, 134, 1, 134, 1, 135, 1, 135, 1, 135, 1, 136, 1, 136, 1, 136, 1,
136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1, 136, 1,
137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 137, 1, 138, 1,
138, 1, 138, 1, 138, 1, 138, 1, 138, 1, 139, 1, 139, 1, 139, 1, 139, 1,
139, 1, 139, 1, 139, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1, 140, 1,
140, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 141, 1, 142, 1, 142, 1,
142, 1, 142, 1, 142, 1, 142, 1, 142, 1, 143, 1, 143, 1, 143, 1, 143, 1,
143, 1, 143, 1, 143, 1, 144, 1, 144, 1, 144, 1, 144, 1, 144, 1, 145, 1,
145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 145, 1, 146, 1, 146, 1,
146, 1, 146, 1, 146, 1, 147, 1, 147, 1, 147, 1, 147, 1, 147, 1, 147, 1,
148, 1, 148, 1, 148, 1, 148, 1, 148, 1, 149, 1, 149, 1, 149, 1, 149, 1,
149, 1, 149, 1, 149, 1, 149, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1,
150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 150, 1, 151, 1, 151, 1,
151, 1, 151, 1, 151, 1, 152, 1, 152, 1, 152, 1, 152, 1, 152, 1, 152, 1,
152, 1, 152, 1, 152, 1, 152, 1, 153, 1, 153, 1, 153, 1, 153, 1, 153, 1,
153, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1, 154, 1,
154, 1, 154, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1, 155, 1,
155, 1, 155, 1, 155, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1, 156, 1,
156, 1, 156, 1, 157, 1, 157, 1, 157, 1, 157, 1, 157, 1, 157, 1, 157, 1,
157, 1, 157, 1, 157, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1, 158, 1,
158, 1, 158, 1, 158, 1, 158, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1,
159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 159, 1, 160, 1, 160, 1, 160, 1,
160, 1, 161, 1, 161, 1, 161, 1, 161, 1, 161, 1, 161, 1, 161, 1, 161, 1,
161, 1, 161, 1, 161, 1, 162, 1, 162, 1, 162, 1, 162, 1, 162, 1, 163, 1,
163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1, 163, 1,
164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 164, 1, 165, 1, 165, 1, 165, 1,
165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1, 165, 1,
165, 1, 166, 1, 166, 1, 166, 1, 166, 1, 166, 1, 167, 1, 167, 1, 167, 1,
167, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, 1, 167, 1, 168, 1,
168, 1, 168, 1, 168, 1, 168, 1, 168, 1, 168, 1, 168, 1, 168, 1, 168, 1,
169, 1, 169, 1, 169, 1, 169, 1, 169, 1, 169, 1, 169, 1, 170, 1, 170, 1,
170, 1, 170, 1, 170, 1, 170, 1, 170, 1, 171, 1, 171, 1, 171, 1, 171, 1,
171, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 172, 1, 173, 1, 173, 1,
173, 1, 173, 1, 173, 1, 173, 1, 173, 1, 174, 1, 174, 1, 174, 1, 174, 1,
174, 1, 174, 1, 175, 1, 175, 1, 175, 1, 175, 1, 175, 1, 175, 1, 176, 1,
176, 1, 176, 1, 176, 1, 176, 1, 177, 1, 177, 1, 177, 1, 177, 1, 177, 1,
177, 1, 177, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1, 178, 1,
179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 179, 1, 180, 1,
180, 1, 180, 1, 180, 1, 180, 1, 181, 1, 181, 1, 181, 1, 181, 1, 181, 1,
181, 1, 181, 1, 182, 1, 182, 1, 182, 1, 183, 1, 183, 1, 183, 1, 183, 1,
183, 1, 183, 1, 183, 1, 183, 1, 184, 1, 184, 1, 184, 1, 184, 5, 184, 1562,
8, 184, 10, 184, 12, 184, 1565, 9, 184, 1, 184, 1, 184, 1, 184, 1, 184,
1, 184, 5, 184, 1572, 8, 184, 10, 184, 12, 184, 1575, 9, 184, 1, 184, 1,
184, 1, 184, 5, 184, 1580, 8, 184, 10, 184, 12, 184, 1583, 9, 184, 1, 184,
1, 184, 1, 184, 5, 184, 1588, 8, 184, 10, 184, 12, 184, 1591, 9, 184, 3,
184, 1593, 8, 184, 1, 185, 4, 185, 1596, 8, 185, 11, 185, 12, 185, 1597,
1, 185, 1, 185, 5, 185, 1602, 8, 185, 10, 185, 12, 185, 1605, 9, 185, 3,
185, 1607, 8, 185, 1, 185, 1, 185, 4, 185, 1611, 8, 185, 11, 185, 12, 185,
1612, 3, 185, 1615, 8, 185, 1, 185, 1, 185, 3, 185, 1619, 8, 185, 1, 185,
4, 185, 1622, 8, 185, 11, 185, 12, 185, 1623, 3, 185, 1626, 8, 185, 1,
185, 1, 185, 1, 185, 1, 185, 4, 185, 1632, 8, 185, 11, 185, 12, 185, 1633,
3, 185, 1636, 8, 185, 1, 186, 1, 186, 5, 186, 1640, 8, 186, 10, 186, 12,
186, 1643, 9, 186, 1, 186, 1, 186, 3, 186, 1647, 8, 186, 1, 187, 1, 187,
1, 187, 1, 187, 5, 187, 1653, 8, 187, 10, 187, 12, 187, 1656, 9, 187, 1,
187, 1, 187, 1, 188, 1, 188, 1, 188, 1, 189, 1, 189, 1, 189, 1, 189, 5,
189, 1667, 8, 189, 10, 189, 12, 189, 1670, 9, 189, 1, 189, 3, 189, 1673,
8, 189, 1, 189, 1, 189, 3, 189, 1677, 8, 189, 1, 189, 1, 189, 1, 190, 1,
190, 1, 190, 1, 190, 5, 190, 1685, 8, 190, 10, 190, 12, 190, 1688, 9, 190,
1, 190, 1, 190, 1, 190, 1, 190, 1, 190, 1, 191, 1, 191, 1, 191, 1, 191,
1, 192, 1, 192, 1, 193, 1, 193, 1, 194, 1, 194, 1, 1686, 0, 195, 1, 1,
3, 2, 5, 3, 7, 4, 9, 5, 11, 6, 13, 7, 15, 8, 17, 9, 19, 10, 21, 11, 23,
12, 25, 13, 27, 14, 29, 15, 31, 16, 33, 17, 35, 18, 37, 19, 39, 20, 41,
21, 43, 22, 45, 23, 47, 24, 49, 25, 51, 26, 53, 27, 55, 28, 57, 29, 59,
30, 61, 31, 63, 32, 65, 33, 67, 34, 69, 35, 71, 36, 73, 37, 75, 38, 77,
39, 79, 40, 81, 41, 83, 42, 85, 43, 87, 44, 89, 45, 91, 46, 93, 47, 95,
48, 97, 49, 99, 50, 101, 51, 103, 52, 105, 53, 107, 54, 109, 55, 111, 56,
113, 57, 115, 58, 117, 59, 119, 60, 121, 61, 123, 62, 125, 63, 127, 64,
129, 65, 131, 66, 133, 67, 135, 68, 137, 69, 139, 70, 141, 71, 143, 72,
145, 73, 147, 74, 149, 75, 151, 76, 153, 77, 155, 78, 157, 79, 159, 80,
161, 81, 163, 82, 165, 83, 167, 84, 169, 85, 171, 86, 173, 87, 175, 88,
177, 89, 179, 90, 181, 91, 183, 92, 185, 93, 187, 94, 189, 95, 191, 96,
193, 97, 195, 98, 197, 99, 199, 100, 201, 101, 203, 102, 205, 103, 207,
104, 209, 105, 211, 106, 213, 107, 215, 108, 217, 109, 219, 110, 221, 111,
223, 112, 225, 113, 227, 114, 229, 115, 231, 116, 233, 117, 235, 118, 237,
119, 239, 120, 241, 121, 243, 122, 245, 123, 247, 124, 249, 125, 251, 126,
253, 127, 255, 128, 257, 129, 259, 130, 261, 131, 263, 132, 265, 133, 267,
134, 269, 135, 271, 136, 273, 137, 275, 138, 277, 139, 279, 140, 281, 141,
283, 142, 285, 143, 287, 144, 289, 145, 291, 146, 293, 147, 295, 148, 297,
149, 299, 150, 301, 151, 303, 152, 305, 153, 307, 154, 309, 155, 311, 156,
313, 157, 315, 158, 317, 159, 319, 160, 321, 161, 323, 162, 325, 163, 327,
164, 329, 165, 331, 166, 333, 167, 335, 168, 337, 169, 339, 170, 341, 171,
343, 172, 345, 173, 347, 174, 349, 175, 351, 176, 353, 177, 355, 178, 357,
179, 359, 180, 361, 181, 363, 182, 365, 183, 367, 184, 369, 185, 371, 186,
373, 187, 375, 188, 377, 189, 379, 190, 381, 191, 383, 192, 385, 193, 387,
0, 389, 0, 1, 0, 38, 2, 0, 65, 65, 97, 97, 2, 0, 66, 66, 98, 98, 2, 0,
79, 79, 111, 111, 2, 0, 82, 82, 114, 114, 2, 0, 84, 84, 116, 116, 2, 0,
67, 67, 99, 99, 2, 0, 73, 73, 105, 105, 2, 0, 78, 78, 110, 110, 2, 0, 68,
68, 100, 100, 2, 0, 70, 70, 102, 102, 2, 0, 69, 69, 101, 101, 2, 0, 76,
76, 108, 108, 2, 0, 89, 89, 121, 121, 2, 0, 90, 90, 122, 122, 2, 0, 83,
83, 115, 115, 2, 0, 72, 72, 104, 104, 2, 0, 85, 85, 117, 117, 2, 0, 77,
77, 109, 109, 2, 0, 71, 71, 103, 103, 2, 0, 87, 87, 119, 119, 2, 0, 75,
75, 107, 107, 2, 0, 80, 80, 112, 112, 2, 0, 88, 88, 120, 120, 2, 0, 86,
86, 118, 118, 2, 0, 74, 74, 106, 106, 2, 0, 81, 81, 113, 113, 1, 0, 34,
34, 1, 0, 96, 96, 1, 0, 93, 93, 3, 0, 65, 90, 95, 95, 97, 122, 4, 0, 48,
57, 65, 90, 95, 95, 97, 122, 2, 0, 43, 43, 45, 45, 3, 0, 36, 36, 58, 58,
64, 64, 1, 0, 39, 39, 2, 0, 10, 10, 13, 13, 3, 0, 9, 11, 13, 13, 32, 32,
3, 0, 48, 57, 65, 70, 97, 102, 1, 0, 48, 57, 1728, 0, 1, 1, 0, 0, 0, 0,
3, 1, 0, 0, 0, 0, 5, 1, 0, 0, 0, 0, 7, 1, 0, 0, 0, 0, 9, 1, 0, 0, 0, 0,
11, 1, 0, 0, 0, 0, 13, 1, 0, 0, 0, 0, 15, 1, 0, 0, 0, 0, 17, 1, 0, 0, 0,
0, 19, 1, 0, 0, 0, 0, 21, 1, 0, 0, 0, 0, 23, 1, 0, 0, 0, 0, 25, 1, 0, 0,
0, 0, 27, 1, 0, 0, 0, 0, 29, 1, 0, 0, 0, 0, 31, 1, 0, 0, 0, 0, 33, 1, 0,
0, 0, 0, 35, 1, 0, 0, 0, 0, 37, 1, 0, 0, 0, 0, 39, 1, 0, 0, 0, 0, 41, 1,
0, 0, 0, 0, 43, 1, 0, 0, 0, 0, 45, 1, 0, 0, 0, 0, 47, 1, 0, 0, 0, 0, 49,
1, 0, 0, 0, 0, 51, 1, 0, 0, 0, 0, 53, 1, 0, 0, 0, 0, 55, 1, 0, 0, 0, 0,
57, 1, 0, 0, 0, 0, 59, 1, 0, 0, 0, 0, 61, 1, 0, 0, 0, 0, 63, 1, 0, 0, 0,
0, 65, 1, 0, 0, 0, 0, 67, 1, 0, 0, 0, 0, 69, 1, 0, 0, 0, 0, 71, 1, 0, 0,
0, 0, 73, 1, 0, 0, 0, 0, 75, 1, 0, 0, 0, 0, 77, 1, 0, 0, 0, 0, 79, 1, 0,
0, 0, 0, 81, 1, 0, 0, 0, 0, 83, 1, 0, 0, 0, 0, 85, 1, 0, 0, 0, 0, 87, 1,
0, 0, 0, 0, 89, 1, 0, 0, 0, 0, 91, 1, 0, 0, 0, 0, 93, 1, 0, 0, 0, 0, 95,
1, 0, 0, 0, 0, 97, 1, 0, 0, 0, 0, 99, 1, 0, 0, 0, 0, 101, 1, 0, 0, 0, 0,
103, 1, 0, 0, 0, 0, 105, 1, 0, 0, 0, 0, 107, 1, 0, 0, 0, 0, 109, 1, 0,
0, 0, 0, 111, 1, 0, 0, 0, 0, 113, 1, 0, 0, 0, 0, 115, 1, 0, 0, 0, 0, 117,
1, 0, 0, 0, 0, 119, 1, 0, 0, 0, 0, 121, 1, 0, 0, 0, 0, 123, 1, 0, 0, 0,
0, 125, 1, 0, 0, 0, 0, 127, 1, 0, 0, 0, 0, 129, 1, 0, 0, 0, 0, 131, 1,
0, 0, 0, 0, 133, 1, 0, 0, 0, 0, 135, 1, 0, 0, 0, 0, 137, 1, 0, 0, 0, 0,
139, 1, 0, 0, 0, 0, 141, 1, 0, 0, 0, 0, 143, 1, 0, 0, 0, 0, 145, 1, 0,
0, 0, 0, 147, 1, 0, 0, 0, 0, 149, 1, 0, 0, 0, 0, 151, 1, 0, 0, 0, 0, 153,
1, 0, 0, 0, 0, 155, 1, 0, 0, 0, 0, 157, 1, 0, 0, 0, 0, 159, 1, 0, 0, 0,
0, 161, 1, 0, 0, 0, 0, 163, 1, 0, 0, 0, 0, 165, 1, 0, 0, 0, 0, 167, 1,
0, 0, 0, 0, 169, 1, 0, 0, 0, 0, 171, 1, 0, 0, 0, 0, 173, 1, 0, 0, 0, 0,
175, 1, 0, 0, 0, 0, 177, 1, 0, 0, 0, 0, 179, 1, 0, 0, 0, 0, 181, 1, 0,
0, 0, 0, 183, 1, 0, 0, 0, 0, 185, 1, 0, 0, 0, 0, 187, 1, 0, 0, 0, 0, 189,
1, 0, 0, 0, 0, 191, 1, 0, 0, 0, 0, 193, 1, 0, 0, 0, 0, 195, 1, 0, 0, 0,
0, 197, 1, 0, 0, 0, 0, 199, 1, 0, 0, 0, 0, 201, 1, 0, 0, 0, 0, 203, 1,
0, 0, 0, 0, 205, 1, 0, 0, 0, 0, 207, 1, 0, 0, 0, 0, 209, 1, 0, 0, 0, 0,
211, 1, 0, 0, 0, 0, 213, 1, 0, 0, 0, 0, 215, 1, 0, 0, 0, 0, 217, 1, 0,
0, 0, 0, 219, 1, 0, 0, 0, 0, 221, 1, 0, 0, 0, 0, 223, 1, 0, 0, 0, 0, 225,
1, 0, 0, 0, 0, 227, 1, 0, 0, 0, 0, 229, 1, 0, 0, 0, 0, 231, 1, 0, 0, 0,
0, 233, 1, 0, 0, 0, 0, 235, 1, 0, 0, 0, 0, 237, 1, 0, 0, 0, 0, 239, 1,
0, 0, 0, 0, 241, 1, 0, 0, 0, 0, 243, 1, 0, 0, 0, 0, 245, 1, 0, 0, 0, 0,
247, 1, 0, 0, 0, 0, 249, 1, 0, 0, 0, 0, 251, 1, 0, 0, 0, 0, 253, 1, 0,
0, 0, 0, 255, 1, 0, 0, 0, 0, 257, 1, 0, 0, 0, 0, 259, 1, 0, 0, 0, 0, 261,
1, 0, 0, 0, 0, 263, 1, 0, 0, 0, 0, 265, 1, 0, 0, 0, 0, 267, 1, 0, 0, 0,
0, 269, 1, 0, 0, 0, 0, 271, 1, 0, 0, 0, 0, 273, 1, 0, 0, 0, 0, 275, 1,
0, 0, 0, 0, 277, 1, 0, 0, 0, 0, 279, 1, 0, 0, 0, 0, 281, 1, 0, 0, 0, 0,
283, 1, 0, 0, 0, 0, 285, 1, 0, 0, 0, 0, 287, 1, 0, 0, 0, 0, 289, 1, 0,
0, 0, 0, 291, 1, 0, 0, 0, 0, 293, 1, 0, 0, 0, 0, 295, 1, 0, 0, 0, 0, 297,
1, 0, 0, 0, 0, 299, 1, 0, 0, 0, 0, 301, 1, 0, 0, 0, 0, 303, 1, 0, 0, 0,
0, 305, 1, 0, 0, 0, 0, 307, 1, 0, 0, 0, 0, 309, 1, 0, 0, 0, 0, 311, 1,
0, 0, 0, 0, 313, 1, 0, 0, 0, 0, 315, 1, 0, 0, 0, 0, 317, 1, 0, 0, 0, 0,
319, 1, 0, 0, 0, 0, 321, 1, 0, 0, 0, 0, 323, 1, 0, 0, 0, 0, 325, 1, 0,
0, 0, 0, 327, 1, 0, 0, 0, 0, 329, 1, 0, 0, 0, 0, 331, 1, 0, 0, 0, 0, 333,
1, 0, 0, 0, 0, 335, 1, 0, 0, 0, 0, 337, 1, 0, 0, 0, 0, 339, 1, 0, 0, 0,
0, 341, 1, 0, 0, 0, 0, 343, 1, 0, 0, 0, 0, 345, 1, 0, 0, 0, 0, 347, 1,
0, 0, 0, 0, 349, 1, 0, 0, 0, 0, 351, 1, 0, 0, 0, 0, 353, 1, 0, 0, 0, 0,
355, 1, 0, 0, 0, 0, 357, 1, 0, 0, 0, 0, 359, 1, 0, 0, 0, 0, 361, 1, 0,
0, 0, 0, 363, 1, 0, 0, 0, 0, 365, 1, 0, 0, 0, 0, 367, 1, 0, 0, 0, 0, 369,
1, 0, 0, 0, 0, 371, 1, 0, 0, 0, 0, 373, 1, 0, 0, 0, 0, 375, 1, 0, 0, 0,
0, 377, 1, 0, 0, 0, 0, 379, 1, 0, 0, 0, 0, 381, 1, 0, 0, 0, 0, 383, 1,
0, 0, 0, 0, 385, 1, 0, 0, 0, 1, 391, 1, 0, 0, 0, 3, 393, 1, 0, 0, 0, 5,
395, 1, 0, 0, 0, 7, 397, 1, 0, 0, 0, 9, 399, 1, 0, 0, 0, 11, 401, 1, 0,
0, 0, 13, 403, 1, 0, 0, 0, 15, 405, 1, 0, 0, 0, 17, 407, 1, 0, 0, 0, 19,
409, 1, 0, 0, 0, 21, 411, 1, 0, 0, 0, 23, 414, 1, 0, 0, 0, 25, 416, 1,
0, 0, 0, 27, 418, 1, 0, 0, 0, 29, 421, 1, 0, 0, 0, 31, 424, 1, 0, 0, 0,
33, 426, 1, 0, 0, 0, 35, 428, 1, 0, 0, 0, 37, 430, 1, 0, 0, 0, 39, 433,
1, 0, 0, 0, 41, 435, 1, 0, 0, 0, 43, 438, 1, 0, 0, 0, 45, 441, 1, 0, 0,
0, 47, 444, 1, 0, 0, 0, 49, 447, 1, 0, 0, 0, 51, 453, 1, 0, 0, 0, 53, 460,
1, 0, 0, 0, 55, 464, 1, 0, 0, 0, 57, 470, 1, 0, 0, 0, 59, 474, 1, 0, 0,
0, 61, 480, 1, 0, 0, 0, 63, 488, 1, 0, 0, 0, 65, 492, 1, 0, 0, 0, 67, 495,
1, 0, 0, 0, 69, 499, 1, 0, 0, 0, 71, 506, 1, 0, 0, 0, 73, 520, 1, 0, 0,
0, 75, 527, 1, 0, 0, 0, 77, 533, 1, 0, 0, 0, 79, 541, 1, 0, 0, 0, 81, 544,
1, 0, 0, 0, 83, 552, 1, 0, 0, 0, 85, 557, 1, 0, 0, 0, 87, 562, 1, 0, 0,
0, 89, 568, 1, 0, 0, 0, 91, 576, 1, 0, 0, 0, 93, 583, 1, 0, 0, 0, 95, 590,
1, 0, 0, 0, 97, 599, 1, 0, 0, 0, 99, 610, 1, 0, 0, 0, 101, 617, 1, 0, 0,
0, 103, 623, 1, 0, 0, 0, 105, 636, 1, 0, 0, 0, 107, 649, 1, 0, 0, 0, 109,
667, 1, 0, 0, 0, 111, 676, 1, 0, 0, 0, 113, 684, 1, 0, 0, 0, 115, 695,
1, 0, 0, 0, 117, 704, 1, 0, 0, 0, 119, 711, 1, 0, 0, 0, 121, 716, 1, 0,
0, 0, 123, 723, 1, 0, 0, 0, 125, 732, 1, 0, 0, 0, 127, 737, 1, 0, 0, 0,
129, 742, 1, 0, 0, 0, 131, 747, 1, 0, 0, 0, 133, 751, 1, 0, 0, 0, 135,
758, 1, 0, 0, 0, 137, 765, 1, 0, 0, 0, 139, 775, 1, 0, 0, 0, 141, 782,
1, 0, 0, 0, 143, 790, 1, 0, 0, 0, 145, 795, 1, 0, 0, 0, 147, 799, 1, 0,
0, 0, 149, 807, 1, 0, 0, 0, 151, 812, 1, 0, 0, 0, 153, 817, 1, 0, 0, 0,
155, 822, 1, 0, 0, 0, 157, 828, 1, 0, 0, 0, 159, 835, 1, 0, 0, 0, 161,
838, 1, 0, 0, 0, 163, 845, 1, 0, 0, 0, 165, 855, 1, 0, 0, 0, 167, 858,
1, 0, 0, 0, 169, 864, 1, 0, 0, 0, 171, 872, 1, 0, 0, 0, 173, 882, 1, 0,
0, 0, 175, 888, 1, 0, 0, 0, 177, 895, 1, 0, 0, 0, 179, 903, 1, 0, 0, 0,
181, 913, 1, 0, 0, 0, 183, 918, 1, 0, 0, 0, 185, 921, 1, 0, 0, 0, 187,
928, 1, 0, 0, 0, 189, 933, 1, 0, 0, 0, 191, 937, 1, 0, 0, 0, 193, 942,
1, 0, 0, 0, 195, 947, 1, 0, 0, 0, 197, 953, 1, 0, 0, 0, 199, 959, 1, 0,
0, 0, 201, 967, 1, 0, 0, 0, 203, 970, 1, 0, 0, 0, 205, 974, 1, 0, 0, 0,
207, 982, 1, 0, 0, 0, 209, 987, 1, 0, 0, 0, 211, 990, 1, 0, 0, 0, 213,
997, 1, 0, 0, 0, 215, 1000, 1, 0, 0, 0, 217, 1003, 1, 0, 0, 0, 219, 1009,
1, 0, 0, 0, 221, 1015, 1, 0, 0, 0, 223, 1020, 1, 0, 0, 0, 225, 1027, 1,
0, 0, 0, 227, 1035, 1, 0, 0, 0, 229, 1041, 1, 0, 0, 0, 231, 1047, 1, 0,
0, 0, 233, 1057, 1, 0, 0, 0, 235, 1068, 1, 0, 0, 0, 237, 1075, 1, 0, 0,
0, 239, 1083, 1, 0, 0, 0, 241, 1091, 1, 0, 0, 0, 243, 1098, 1, 0, 0, 0,
245, 1106, 1, 0, 0, 0, 247, 1115, 1, 0, 0, 0, 249, 1125, 1, 0, 0, 0, 251,
1131, 1, 0, 0, 0, 253, 1140, 1, 0, 0, 0, 255, 1144, 1, 0, 0, 0, 257, 1149,
1, 0, 0, 0, 259, 1159, 1, 0, 0, 0, 261, 1166, 1, 0, 0, 0, 263, 1170, 1,
0, 0, 0, 265, 1176, 1, 0, 0, 0, 267, 1181, 1, 0, 0, 0, 269, 1191, 1, 0,
0, 0, 271, 1196, 1, 0, 0, 0, 273, 1199, 1, 0, 0, 0, 275, 1211, 1, 0, 0,
0, 277, 1219, 1, 0, 0, 0, 279, 1225, 1, 0, 0, 0, 281, 1232, 1, 0, 0, 0,
283, 1239, 1, 0, 0, 0, 285, 1245, 1, 0, 0, 0, 287, 1252, 1, 0, 0, 0, 289,
1259, 1, 0, 0, 0, 291, 1264, 1, 0, 0, 0, 293, 1272, 1, 0, 0, 0, 295, 1277,
1, 0, 0, 0, 297, 1283, 1, 0, 0, 0, 299, 1288, 1, 0, 0, 0, 301, 1296, 1,
0, 0, 0, 303, 1308, 1, 0, 0, 0, 305, 1313, 1, 0, 0, 0, 307, 1323, 1, 0,
0, 0, 309, 1329, 1, 0, 0, 0, 311, 1339, 1, 0, 0, 0, 313, 1349, 1, 0, 0,
0, 315, 1357, 1, 0, 0, 0, 317, 1367, 1, 0, 0, 0, 319, 1377, 1, 0, 0, 0,
321, 1388, 1, 0, 0, 0, 323, 1392, 1, 0, 0, 0, 325, 1403, 1, 0, 0, 0, 327,
1408, 1, 0, 0, 0, 329, 1418, 1, 0, 0, 0, 331, 1424, 1, 0, 0, 0, 333, 1437,
1, 0, 0, 0, 335, 1442, 1, 0, 0, 0, 337, 1453, 1, 0, 0, 0, 339, 1463, 1,
0, 0, 0, 341, 1470, 1, 0, 0, 0, 343, 1477, 1, 0, 0, 0, 345, 1482, 1, 0,
0, 0, 347, 1488, 1, 0, 0, 0, 349, 1495, 1, 0, 0, 0, 351, 1501, 1, 0, 0,
0, 353, 1507, 1, 0, 0, 0, 355, 1512, 1, 0, 0, 0, 357, 1519, 1, 0, 0, 0,
359, 1526, 1, 0, 0, 0, 361, 1534, 1, 0, 0, 0, 363, 1539, 1, 0, 0, 0, 365,
1546, 1, 0, 0, 0, 367, 1549, 1, 0, 0, 0, 369, 1592, 1, 0, 0, 0, 371, 1635,
1, 0, 0, 0, 373, 1646, 1, 0, 0, 0, 375, 1648, 1, 0, 0, 0, 377, 1659, 1,
0, 0, 0, 379, 1662, 1, 0, 0, 0, 381, 1680, 1, 0, 0, 0, 383, 1694, 1, 0,
0, 0, 385, 1698, 1, 0, 0, 0, 387, 1700, 1, 0, 0, 0, 389, 1702, 1, 0, 0,
0, 391, 392, 5, 59, 0, 0, 392, 2, 1, 0, 0, 0, 393, 394, 5, 46, 0, 0, 394,
4, 1, 0, 0, 0, 395, 396, 5, 40, 0, 0, 396, 6, 1, 0, 0, 0, 397, 398, 5,
41, 0, 0, 398, 8, 1, 0, 0, 0, 399, 400, 5, 44, 0, 0, 400, 10, 1, 0, 0,
0, 401, 402, 5, 61, 0, 0, 402, 12, 1, 0, 0, 0, 403, 404, 5, 42, 0, 0, 404,
14, 1, 0, 0, 0, 405, 406, 5, 43, 0, 0, 406, 16, 1, 0, 0, 0, 407, 408, 5,
45, 0, 0, 408, 18, 1, 0, 0, 0, 409, 410, 5, 126, 0, 0, 410, 20, 1, 0, 0,
0, 411, 412, 5, 124, 0, 0, 412, 413, 5, 124, 0, 0, 413, 22, 1, 0, 0, 0,
414, 415, 5, 47, 0, 0, 415, 24, 1, 0, 0, 0, 416, 417, 5, 37, 0, 0, 417,
26, 1, 0, 0, 0, 418, 419, 5, 60, 0, 0, 419, 420, 5, 60, 0, 0, 420, 28,
1, 0, 0, 0, 421, 422, 5, 62, 0, 0, 422, 423, 5, 62, 0, 0, 423, 30, 1, 0,
0, 0, 424, 425, 5, 38, 0, 0, 425, 32, 1, 0, 0, 0, 426, 427, 5, 124, 0,
0, 427, 34, 1, 0, 0, 0, 428, 429, 5, 60, 0, 0, 429, 36, 1, 0, 0, 0, 430,
431, 5, 60, 0, 0, 431, 432, 5, 61, 0, 0, 432, 38, 1, 0, 0, 0, 433, 434,
5, 62, 0, 0, 434, 40, 1, 0, 0, 0, 435, 436, 5, 62, 0, 0, 436, 437, 5, 61,
0, 0, 437, 42, 1, 0, 0, 0, 438, 439, 5, 61, 0, 0, 439, 440, 5, 61, 0, 0,
440, 44, 1, 0, 0, 0, 441, 442, 5, 33, 0, 0, 442, 443, 5, 61, 0, 0, 443,
46, 1, 0, 0, 0, 444, 445, 5, 60, 0, 0, 445, 446, 5, 62, 0, 0, 446, 48,
1, 0, 0, 0, 447, 448, 7, 0, 0, 0, 448, 449, 7, 1, 0, 0, 449, 450, 7, 2,
0, 0, 450, 451, 7, 3, 0, 0, 451, 452, 7, 4, 0, 0, 452, 50, 1, 0, 0, 0,
453, 454, 7, 0, 0, 0, 454, 455, 7, 5, 0, 0, 455, 456, 7, 4, 0, 0, 456,
457, 7, 6, 0, 0, 457, 458, 7, 2, 0, 0, 458, 459, 7, 7, 0, 0, 459, 52, 1,
0, 0, 0, 460, 461, 7, 0, 0, 0, 461, 462, 7, 8, 0, 0, 462, 463, 7, 8, 0,
0, 463, 54, 1, 0, 0, 0, 464, 465, 7, 0, 0, 0, 465, 466, 7, 9, 0, 0, 466,
467, 7, 4, 0, 0, 467, 468, 7, 10, 0, 0, 468, 469, 7, 3, 0, 0, 469, 56,
1, 0, 0, 0, 470, 471, 7, 0, 0, 0, 471, 472, 7, 11, 0, 0, 472, 473, 7, 11,
0, 0, 473, 58, 1, 0, 0, 0, 474, 475, 7, 0, 0, 0, 475, 476, 7, 11, 0, 0,
476, 477, 7, 4, 0, 0, 477, 478, 7, 10, 0, 0, 478, 479, 7, 3, 0, 0, 479,
60, 1, 0, 0, 0, 480, 481, 7, 0, 0, 0, 481, 482, 7, 7, 0, 0, 482, 483, 7,
0, 0, 0, 483, 484, 7, 11, 0, 0, 484, 485, 7, 12, 0, 0, 485, 486, 7, 13,
0, 0, 486, 487, 7, 10, 0, 0, 487, 62, 1, 0, 0, 0, 488, 489, 7, 0, 0, 0,
489, 490, 7, 7, 0, 0, 490, 491, 7, 8, 0, 0, 491, 64, 1, 0, 0, 0, 492, 493,
7, 0, 0, 0, 493, 494, 7, 14, 0, 0, 494, 66, 1, 0, 0, 0, 495, 496, 7, 0,
0, 0, 496, 497, 7, 14, 0, 0, 497, 498, 7, 5, 0, 0, 498, 68, 1, 0, 0, 0,
499, 500, 7, 0, 0, 0, 500, 501, 7, 4, 0, 0, 501, 502, 7, 4, 0, 0, 502,
503, 7, 0, 0, 0, 503, 504, 7, 5, 0, 0, 504, 505, 7, 15, 0, 0, 505, 70,
1, 0, 0, 0, 506, 507, 7, 0, 0, 0, 507, 508, 7, 16, 0, 0, 508, 509, 7, 4,
0, 0, 509, 510, 7, 2, 0, 0, 510, 511, 7, 6, 0, 0, 511, 512, 7, 7, 0, 0,
512, 513, 7, 5, 0, 0, 513, 514, 7, 3, 0, 0, 514, 515, 7, 10, 0, 0, 515,
516, 7, 17, 0, 0, 516, 517, 7, 10, 0, 0, 517, 518, 7, 7, 0, 0, 518, 519,
7, 4, 0, 0, 519, 72, 1, 0, 0, 0, 520, 521, 7, 1, 0, 0, 521, 522, 7, 10,
0, 0, 522, 523, 7, 9, 0, 0, 523, 524, 7, 2, 0, 0, 524, 525, 7, 3, 0, 0,
525, 526, 7, 10, 0, 0, 526, 74, 1, 0, 0, 0, 527, 528, 7, 1, 0, 0, 528,
529, 7, 10, 0, 0, 529, 530, 7, 18, 0, 0, 530, 531, 7, 6, 0, 0, 531, 532,
7, 7, 0, 0, 532, 76, 1, 0, 0, 0, 533, 534, 7, 1, 0, 0, 534, 535, 7, 10,
0, 0, 535, 536, 7, 4, 0, 0, 536, 537, 7, 19, 0, 0, 537, 538, 7, 10, 0,
0, 538, 539, 7, 10, 0, 0, 539, 540, 7, 7, 0, 0, 540, 78, 1, 0, 0, 0, 541,
542, 7, 1, 0, 0, 542, 543, 7, 12, 0, 0, 543, 80, 1, 0, 0, 0, 544, 545,
7, 5, 0, 0, 545, 546, 7, 0, 0, 0, 546, 547, 7, 14, 0, 0, 547, 548, 7, 5,
0, 0, 548, 549, 7, 0, 0, 0, 549, 550, 7, 8, 0, 0, 550, 551, 7, 10, 0, 0,
551, 82, 1, 0, 0, 0, 552, 553, 7, 5, 0, 0, 553, 554, 7, 0, 0, 0, 554, 555,
7, 14, 0, 0, 555, 556, 7, 10, 0, 0, 556, 84, 1, 0, 0, 0, 557, 558, 7, 5,
0, 0, 558, 559, 7, 0, 0, 0, 559, 560, 7, 14, 0, 0, 560, 561, 7, 4, 0, 0,
561, 86, 1, 0, 0, 0, 562, 563, 7, 5, 0, 0, 563, 564, 7, 15, 0, 0, 564,
565, 7, 10, 0, 0, 565, 566, 7, 5, 0, 0, 566, 567, 7, 20, 0, 0, 567, 88,
1, 0, 0, 0, 568, 569, 7, 5, 0, 0, 569, 570, 7, 2, 0, 0, 570, 571, 7, 11,
0, 0, 571, 572, 7, 11, 0, 0, 572, 573, 7, 0, 0, 0, 573, 574, 7, 4, 0, 0,
574, 575, 7, 10, 0, 0, 575, 90, 1, 0, 0, 0, 576, 577, 7, 5, 0, 0, 577,
578, 7, 2, 0, 0, 578, 579, 7, 11, 0, 0, 579, 580, 7, 16, 0, 0, 580, 581,
7, 17, 0, 0, 581, 582, 7, 7, 0, 0, 582, 92, 1, 0, 0, 0, 583, 584, 7, 5,
0, 0, 584, 585, 7, 2, 0, 0, 585, 586, 7, 17, 0, 0, 586, 587, 7, 17, 0,
0, 587, 588, 7, 6, 0, 0, 588, 589, 7, 4, 0, 0, 589, 94, 1, 0, 0, 0, 590,
591, 7, 5, 0, 0, 591, 592, 7, 2, 0, 0, 592, 593, 7, 7, 0, 0, 593, 594,
7, 9, 0, 0, 594, 595, 7, 11, 0, 0, 595, 596, 7, 6, 0, 0, 596, 597, 7, 5,
0, 0, 597, 598, 7, 4, 0, 0, 598, 96, 1, 0, 0, 0, 599, 600, 7, 5, 0, 0,
600, 601, 7, 2, 0, 0, 601, 602, 7, 7, 0, 0, 602, 603, 7, 14, 0, 0, 603,
604, 7, 4, 0, 0, 604, 605, 7, 3, 0, 0, 605, 606, 7, 0, 0, 0, 606, 607,
7, 6, 0, 0, 607, 608, 7, 7, 0, 0, 608, 609, 7, 4, 0, 0, 609, 98, 1, 0,
0, 0, 610, 611, 7, 5, 0, 0, 611, 612, 7, 3, 0, 0, 612, 613, 7, 10, 0, 0,
613, 614, 7, 0, 0, 0, 614, 615, 7, 4, 0, 0, 615, 616, 7, 10, 0, 0, 616,
100, 1, 0, 0, 0, 617, 618, 7, 5, 0, 0, 618, 619, 7, 3, 0, 0, 619, 620,
7, 2, 0, 0, 620, 621, 7, 14, 0, 0, 621, 622, 7, 14, 0, 0, 622, 102, 1,
0, 0, 0, 623, 624, 7, 5, 0, 0, 624, 625, 7, 16, 0, 0, 625, 626, 7, 3, 0,
0, 626, 627, 7, 3, 0, 0, 627, 628, 7, 10, 0, 0, 628, 629, 7, 7, 0, 0, 629,
630, 7, 4, 0, 0, 630, 631, 5, 95, 0, 0, 631, 632, 7, 8, 0, 0, 632, 633,
7, 0, 0, 0, 633, 634, 7, 4, 0, 0, 634, 635, 7, 10, 0, 0, 635, 104, 1, 0,
0, 0, 636, 637, 7, 5, 0, 0, 637, 638, 7, 16, 0, 0, 638, 639, 7, 3, 0, 0,
639, 640, 7, 3, 0, 0, 640, 641, 7, 10, 0, 0, 641, 642, 7, 7, 0, 0, 642,
643, 7, 4, 0, 0, 643, 644, 5, 95, 0, 0, 644, 645, 7, 4, 0, 0, 645, 646,
7, 6, 0, 0, 646, 647, 7, 17, 0, 0, 647, 648, 7, 10, 0, 0, 648, 106, 1,
0, 0, 0, 649, 650, 7, 5, 0, 0, 650, 651, 7, 16, 0, 0, 651, 652, 7, 3, 0,
0, 652, 653, 7, 3, 0, 0, 653, 654, 7, 10, 0, 0, 654, 655, 7, 7, 0, 0, 655,
656, 7, 4, 0, 0, 656, 657, 5, 95, 0, 0, 657, 658, 7, 4, 0, 0, 658, 659,
7, 6, 0, 0, 659, 660, 7, 17, 0, 0, 660, 661, 7, 10, 0, 0, 661, 662, 7,
14, 0, 0, 662, 663, 7, 4, 0, 0, 663, 664, 7, 0, 0, 0, 664, 665, 7, 17,
0, 0, 665, 666, 7, 21, 0, 0, 666, 108, 1, 0, 0, 0, 667, 668, 7, 8, 0, 0,
668, 669, 7, 0, 0, 0, 669, 670, 7, 4, 0, 0, 670, 671, 7, 0, 0, 0, 671,
672, 7, 1, 0, 0, 672, 673, 7, 0, 0, 0, 673, 674, 7, 14, 0, 0, 674, 675,
7, 10, 0, 0, 675, 110, 1, 0, 0, 0, 676, 677, 7, 8, 0, 0, 677, 678, 7, 10,
0, 0, 678, 679, 7, 9, 0, 0, 679, 680, 7, 0, 0, 0, 680, 681, 7, 16, 0, 0,
681, 682, 7, 11, 0, 0, 682, 683, 7, 4, 0, 0, 683, 112, 1, 0, 0, 0, 684,
685, 7, 8, 0, 0, 685, 686, 7, 10, 0, 0, 686, 687, 7, 9, 0, 0, 687, 688,
7, 10, 0, 0, 688, 689, 7, 3, 0, 0, 689, 690, 7, 3, 0, 0, 690, 691, 7, 0,
0, 0, 691, 692, 7, 1, 0, 0, 692, 693, 7, 11, 0, 0, 693, 694, 7, 10, 0,
0, 694, 114, 1, 0, 0, 0, 695, 696, 7, 8, 0, 0, 696, 697, 7, 10, 0, 0, 697,
698, 7, 9, 0, 0, 698, 699, 7, 10, 0, 0, 699, 700, 7, 3, 0, 0, 700, 701,
7, 3, 0, 0, 701, 702, 7, 10, 0, 0, 702, 703, 7, 8, 0, 0, 703, 116, 1, 0,
0, 0, 704, 705, 7, 8, 0, 0, 705, 706, 7, 10, 0, 0, 706, 707, 7, 11, 0,
0, 707, 708, 7, 10, 0, 0, 708, 709, 7, 4, 0, 0, 709, 710, 7, 10, 0, 0,
710, 118, 1, 0, 0, 0, 711, 712, 7, 8, 0, 0, 712, 713, 7, 10, 0, 0, 713,
714, 7, 14, 0, 0, 714, 715, 7, 5, 0, 0, 715, 120, 1, 0, 0, 0, 716, 717,
7, 8, 0, 0, 717, 718, 7, 10, 0, 0, 718, 719, 7, 4, 0, 0, 719, 720, 7, 0,
0, 0, 720, 721, 7, 5, 0, 0, 721, 722, 7, 15, 0, 0, 722, 122, 1, 0, 0, 0,
723, 724, 7, 8, 0, 0, 724, 725, 7, 6, 0, 0, 725, 726, 7, 14, 0, 0, 726,
727, 7, 4, 0, 0, 727, 728, 7, 6, 0, 0, 728, 729, 7, 7, 0, 0, 729, 730,
7, 5, 0, 0, 730, 731, 7, 4, 0, 0, 731, 124, 1, 0, 0, 0, 732, 733, 7, 8,
0, 0, 733, 734, 7, 3, 0, 0, 734, 735, 7, 2, 0, 0, 735, 736, 7, 21, 0, 0,
736, 126, 1, 0, 0, 0, 737, 738, 7, 10, 0, 0, 738, 739, 7, 0, 0, 0, 739,
740, 7, 5, 0, 0, 740, 741, 7, 15, 0, 0, 741, 128, 1, 0, 0, 0, 742, 743,
7, 10, 0, 0, 743, 744, 7, 11, 0, 0, 744, 745, 7, 14, 0, 0, 745, 746, 7,
10, 0, 0, 746, 130, 1, 0, 0, 0, 747, 748, 7, 10, 0, 0, 748, 749, 7, 7,
0, 0, 749, 750, 7, 8, 0, 0, 750, 132, 1, 0, 0, 0, 751, 752, 7, 10, 0, 0,
752, 753, 7, 14, 0, 0, 753, 754, 7, 5, 0, 0, 754, 755, 7, 0, 0, 0, 755,
756, 7, 21, 0, 0, 756, 757, 7, 10, 0, 0, 757, 134, 1, 0, 0, 0, 758, 759,
7, 10, 0, 0, 759, 760, 7, 22, 0, 0, 760, 761, 7, 5, 0, 0, 761, 762, 7,
10, 0, 0, 762, 763, 7, 21, 0, 0, 763, 764, 7, 4, 0, 0, 764, 136, 1, 0,
0, 0, 765, 766, 7, 10, 0, 0, 766, 767, 7, 22, 0, 0, 767, 768, 7, 5, 0,
0, 768, 769, 7, 11, 0, 0, 769, 770, 7, 16, 0, 0, 770, 771, 7, 14, 0, 0,
771, 772, 7, 6, 0, 0, 772, 773, 7, 23, 0, 0, 773, 774, 7, 10, 0, 0, 774,
138, 1, 0, 0, 0, 775, 776, 7, 10, 0, 0, 776, 777, 7, 22, 0, 0, 777, 778,
7, 6, 0, 0, 778, 779, 7, 14, 0, 0, 779, 780, 7, 4, 0, 0, 780, 781, 7, 14,
0, 0, 781, 140, 1, 0, 0, 0, 782, 783, 7, 10, 0, 0, 783, 784, 7, 22, 0,
0, 784, 785, 7, 21, 0, 0, 785, 786, 7, 11, 0, 0, 786, 787, 7, 0, 0, 0,
787, 788, 7, 6, 0, 0, 788, 789, 7, 7, 0, 0, 789, 142, 1, 0, 0, 0, 790,
791, 7, 9, 0, 0, 791, 792, 7, 0, 0, 0, 792, 793, 7, 6, 0, 0, 793, 794,
7, 11, 0, 0, 794, 144, 1, 0, 0, 0, 795, 796, 7, 9, 0, 0, 796, 797, 7, 2,
0, 0, 797, 798, 7, 3, 0, 0, 798, 146, 1, 0, 0, 0, 799, 800, 7, 9, 0, 0,
800, 801, 7, 2, 0, 0, 801, 802, 7, 3, 0, 0, 802, 803, 7, 10, 0, 0, 803,
804, 7, 6, 0, 0, 804, 805, 7, 18, 0, 0, 805, 806, 7, 7, 0, 0, 806, 148,
1, 0, 0, 0, 807, 808, 7, 9, 0, 0, 808, 809, 7, 3, 0, 0, 809, 810, 7, 2,
0, 0, 810, 811, 7, 17, 0, 0, 811, 150, 1, 0, 0, 0, 812, 813, 7, 9, 0, 0,
813, 814, 7, 16, 0, 0, 814, 815, 7, 11, 0, 0, 815, 816, 7, 11, 0, 0, 816,
152, 1, 0, 0, 0, 817, 818, 7, 18, 0, 0, 818, 819, 7, 11, 0, 0, 819, 820,
7, 2, 0, 0, 820, 821, 7, 1, 0, 0, 821, 154, 1, 0, 0, 0, 822, 823, 7, 18,
0, 0, 823, 824, 7, 3, 0, 0, 824, 825, 7, 2, 0, 0, 825, 826, 7, 16, 0, 0,
826, 827, 7, 21, 0, 0, 827, 156, 1, 0, 0, 0, 828, 829, 7, 15, 0, 0, 829,
830, 7, 0, 0, 0, 830, 831, 7, 23, 0, 0, 831, 832, 7, 6, 0, 0, 832, 833,
7, 7, 0, 0, 833, 834, 7, 18, 0, 0, 834, 158, 1, 0, 0, 0, 835, 836, 7, 6,
0, 0, 836, 837, 7, 9, 0, 0, 837, 160, 1, 0, 0, 0, 838, 839, 7, 6, 0, 0,
839, 840, 7, 18, 0, 0, 840, 841, 7, 7, 0, 0, 841, 842, 7, 2, 0, 0, 842,
843, 7, 3, 0, 0, 843, 844, 7, 10, 0, 0, 844, 162, 1, 0, 0, 0, 845, 846,
7, 6, 0, 0, 846, 847, 7, 17, 0, 0, 847, 848, 7, 17, 0, 0, 848, 849, 7,
10, 0, 0, 849, 850, 7, 8, 0, 0, 850, 851, 7, 6, 0, 0, 851, 852, 7, 0, 0,
0, 852, 853, 7, 4, 0, 0, 853, 854, 7, 10, 0, 0, 854, 164, 1, 0, 0, 0, 855,
856, 7, 6, 0, 0, 856, 857, 7, 7, 0, 0, 857, 166, 1, 0, 0, 0, 858, 859,
7, 6, 0, 0, 859, 860, 7, 7, 0, 0, 860, 861, 7, 8, 0, 0, 861, 862, 7, 10,
0, 0, 862, 863, 7, 22, 0, 0, 863, 168, 1, 0, 0, 0, 864, 865, 7, 6, 0, 0,
865, 866, 7, 7, 0, 0, 866, 867, 7, 8, 0, 0, 867, 868, 7, 10, 0, 0, 868,
869, 7, 22, 0, 0, 869, 870, 7, 10, 0, 0, 870, 871, 7, 8, 0, 0, 871, 170,
1, 0, 0, 0, 872, 873, 7, 6, 0, 0, 873, 874, 7, 7, 0, 0, 874, 875, 7, 6,
0, 0, 875, 876, 7, 4, 0, 0, 876, 877, 7, 6, 0, 0, 877, 878, 7, 0, 0, 0,
878, 879, 7, 11, 0, 0, 879, 880, 7, 11, 0, 0, 880, 881, 7, 12, 0, 0, 881,
172, 1, 0, 0, 0, 882, 883, 7, 6, 0, 0, 883, 884, 7, 7, 0, 0, 884, 885,
7, 7, 0, 0, 885, 886, 7, 10, 0, 0, 886, 887, 7, 3, 0, 0, 887, 174, 1, 0,
0, 0, 888, 889, 7, 6, 0, 0, 889, 890, 7, 7, 0, 0, 890, 891, 7, 14, 0, 0,
891, 892, 7, 10, 0, 0, 892, 893, 7, 3, 0, 0, 893, 894, 7, 4, 0, 0, 894,
176, 1, 0, 0, 0, 895, 896, 7, 6, 0, 0, 896, 897, 7, 7, 0, 0, 897, 898,
7, 14, 0, 0, 898, 899, 7, 4, 0, 0, 899, 900, 7, 10, 0, 0, 900, 901, 7,
0, 0, 0, 901, 902, 7, 8, 0, 0, 902, 178, 1, 0, 0, 0, 903, 904, 7, 6, 0,
0, 904, 905, 7, 7, 0, 0, 905, 906, 7, 4, 0, 0, 906, 907, 7, 10, 0, 0, 907,
908, 7, 3, 0, 0, 908, 909, 7, 14, 0, 0, 909, 910, 7, 10, 0, 0, 910, 911,
7, 5, 0, 0, 911, 912, 7, 4, 0, 0, 912, 180, 1, 0, 0, 0, 913, 914, 7, 6,
0, 0, 914, 915, 7, 7, 0, 0, 915, 916, 7, 4, 0, 0, 916, 917, 7, 2, 0, 0,
917, 182, 1, 0, 0, 0, 918, 919, 7, 6, 0, 0, 919, 920, 7, 14, 0, 0, 920,
184, 1, 0, 0, 0, 921, 922, 7, 6, 0, 0, 922, 923, 7, 14, 0, 0, 923, 924,
7, 7, 0, 0, 924, 925, 7, 16, 0, 0, 925, 926, 7, 11, 0, 0, 926, 927, 7,
11, 0, 0, 927, 186, 1, 0, 0, 0, 928, 929, 7, 24, 0, 0, 929, 930, 7, 2,
0, 0, 930, 931, 7, 6, 0, 0, 931, 932, 7, 7, 0, 0, 932, 188, 1, 0, 0, 0,
933, 934, 7, 20, 0, 0, 934, 935, 7, 10, 0, 0, 935, 936, 7, 12, 0, 0, 936,
190, 1, 0, 0, 0, 937, 938, 7, 11, 0, 0, 938, 939, 7, 10, 0, 0, 939, 940,
7, 9, 0, 0, 940, 941, 7, 4, 0, 0, 941, 192, 1, 0, 0, 0, 942, 943, 7, 11,
0, 0, 943, 944, 7, 6, 0, 0, 944, 945, 7, 20, 0, 0, 945, 946, 7, 10, 0,
0, 946, 194, 1, 0, 0, 0, 947, 948, 7, 11, 0, 0, 948, 949, 7, 6, 0, 0, 949,
950, 7, 17, 0, 0, 950, 951, 7, 6, 0, 0, 951, 952, 7, 4, 0, 0, 952, 196,
1, 0, 0, 0, 953, 954, 7, 17, 0, 0, 954, 955, 7, 0, 0, 0, 955, 956, 7, 4,
0, 0, 956, 957, 7, 5, 0, 0, 957, 958, 7, 15, 0, 0, 958, 198, 1, 0, 0, 0,
959, 960, 7, 7, 0, 0, 960, 961, 7, 0, 0, 0, 961, 962, 7, 4, 0, 0, 962,
963, 7, 16, 0, 0, 963, 964, 7, 3, 0, 0, 964, 965, 7, 0, 0, 0, 965, 966,
7, 11, 0, 0, 966, 200, 1, 0, 0, 0, 967, 968, 7, 7, 0, 0, 968, 969, 7, 2,
0, 0, 969, 202, 1, 0, 0, 0, 970, 971, 7, 7, 0, 0, 971, 972, 7, 2, 0, 0,
972, 973, 7, 4, 0, 0, 973, 204, 1, 0, 0, 0, 974, 975, 7, 7, 0, 0, 975,
976, 7, 2, 0, 0, 976, 977, 7, 4, 0, 0, 977, 978, 7, 7, 0, 0, 978, 979,
7, 16, 0, 0, 979, 980, 7, 11, 0, 0, 980, 981, 7, 11, 0, 0, 981, 206, 1,
0, 0, 0, 982, 983, 7, 7, 0, 0, 983, 984, 7, 16, 0, 0, 984, 985, 7, 11,
0, 0, 985, 986, 7, 11, 0, 0, 986, 208, 1, 0, 0, 0, 987, 988, 7, 2, 0, 0,
988, 989, 7, 9, 0, 0, 989, 210, 1, 0, 0, 0, 990, 991, 7, 2, 0, 0, 991,
992, 7, 9, 0, 0, 992, 993, 7, 9, 0, 0, 993, 994, 7, 14, 0, 0, 994, 995,
7, 10, 0, 0, 995, 996, 7, 4, 0, 0, 996, 212, 1, 0, 0, 0, 997, 998, 7, 2,
0, 0, 998, 999, 7, 7, 0, 0, 999, 214, 1, 0, 0, 0, 1000, 1001, 7, 2, 0,
0, 1001, 1002, 7, 3, 0, 0, 1002, 216, 1, 0, 0, 0, 1003, 1004, 7, 2, 0,
0, 1004, 1005, 7, 3, 0, 0, 1005, 1006, 7, 8, 0, 0, 1006, 1007, 7, 10, 0,
0, 1007, 1008, 7, 3, 0, 0, 1008, 218, 1, 0, 0, 0, 1009, 1010, 7, 2, 0,
0, 1010, 1011, 7, 16, 0, 0, 1011, 1012, 7, 4, 0, 0, 1012, 1013, 7, 10,
0, 0, 1013, 1014, 7, 3, 0, 0, 1014, 220, 1, 0, 0, 0, 1015, 1016, 7, 21,
0, 0, 1016, 1017, 7, 11, 0, 0, 1017, 1018, 7, 0, 0, 0, 1018, 1019, 7, 7,
0, 0, 1019, 222, 1, 0, 0, 0, 1020, 1021, 7, 21, 0, 0, 1021, 1022, 7, 3,
0, 0, 1022, 1023, 7, 0, 0, 0, 1023, 1024, 7, 18, 0, 0, 1024, 1025, 7, 17,
0, 0, 1025, 1026, 7, 0, 0, 0, 1026, 224, 1, 0, 0, 0, 1027, 1028, 7, 21,
0, 0, 1028, 1029, 7, 3, 0, 0, 1029, 1030, 7, 6, 0, 0, 1030, 1031, 7, 17,
0, 0, 1031, 1032, 7, 0, 0, 0, 1032, 1033, 7, 3, 0, 0, 1033, 1034, 7, 12,
0, 0, 1034, 226, 1, 0, 0, 0, 1035, 1036, 7, 25, 0, 0, 1036, 1037, 7, 16,
0, 0, 1037, 1038, 7, 10, 0, 0, 1038, 1039, 7, 3, 0, 0, 1039, 1040, 7, 12,
0, 0, 1040, 228, 1, 0, 0, 0, 1041, 1042, 7, 3, 0, 0, 1042, 1043, 7, 0,
0, 0, 1043, 1044, 7, 6, 0, 0, 1044, 1045, 7, 14, 0, 0, 1045, 1046, 7, 10,
0, 0, 1046, 230, 1, 0, 0, 0, 1047, 1048, 7, 3, 0, 0, 1048, 1049, 7, 10,
0, 0, 1049, 1050, 7, 5, 0, 0, 1050, 1051, 7, 16, 0, 0, 1051, 1052, 7, 3,
0, 0, 1052, 1053, 7, 14, 0, 0, 1053, 1054, 7, 6, 0, 0, 1054, 1055, 7, 23,
0, 0, 1055, 1056, 7, 10, 0, 0, 1056, 232, 1, 0, 0, 0, 1057, 1058, 7, 3,
0, 0, 1058, 1059, 7, 10, 0, 0, 1059, 1060, 7, 9, 0, 0, 1060, 1061, 7, 10,
0, 0, 1061, 1062, 7, 3, 0, 0, 1062, 1063, 7, 10, 0, 0, 1063, 1064, 7, 7,
0, 0, 1064, 1065, 7, 5, 0, 0, 1065, 1066, 7, 10, 0, 0, 1066, 1067, 7, 14,
0, 0, 1067, 234, 1, 0, 0, 0, 1068, 1069, 7, 3, 0, 0, 1069, 1070, 7, 10,
0, 0, 1070, 1071, 7, 18, 0, 0, 1071, 1072, 7, 10, 0, 0, 1072, 1073, 7,
22, 0, 0, 1073, 1074, 7, 21, 0, 0, 1074, 236, 1, 0, 0, 0, 1075, 1076, 7,
3, 0, 0, 1076, 1077, 7, 10, 0, 0, 1077, 1078, 7, 6, 0, 0, 1078, 1079, 7,
7, 0, 0, 1079, 1080, 7, 8, 0, 0, 1080, 1081, 7, 10, 0, 0, 1081, 1082, 7,
22, 0, 0, 1082, 238, 1, 0, 0, 0, 1083, 1084, 7, 3, 0, 0, 1084, 1085, 7,
10, 0, 0, 1085, 1086, 7, 11, 0, 0, 1086, 1087, 7, 10, 0, 0, 1087, 1088,
7, 0, 0, 0, 1088, 1089, 7, 14, 0, 0, 1089, 1090, 7, 10, 0, 0, 1090, 240,
1, 0, 0, 0, 1091, 1092, 7, 3, 0, 0, 1092, 1093, 7, 10, 0, 0, 1093, 1094,
7, 7, 0, 0, 1094, 1095, 7, 0, 0, 0, 1095, 1096, 7, 17, 0, 0, 1096, 1097,
7, 10, 0, 0, 1097, 242, 1, 0, 0, 0, 1098, 1099, 7, 3, 0, 0, 1099, 1100,
7, 10, 0, 0, 1100, 1101, 7, 21, 0, 0, 1101, 1102, 7, 11, 0, 0, 1102, 1103,
7, 0, 0, 0, 1103, 1104, 7, 5, 0, 0, 1104, 1105, 7, 10, 0, 0, 1105, 244,
1, 0, 0, 0, 1106, 1107, 7, 3, 0, 0, 1107, 1108, 7, 10, 0, 0, 1108, 1109,
7, 14, 0, 0, 1109, 1110, 7, 4, 0, 0, 1110, 1111, 7, 3, 0, 0, 1111, 1112,
7, 6, 0, 0, 1112, 1113, 7, 5, 0, 0, 1113, 1114, 7, 4, 0, 0, 1114, 246,
1, 0, 0, 0, 1115, 1116, 7, 3, 0, 0, 1116, 1117, 7, 10, 0, 0, 1117, 1118,
7, 4, 0, 0, 1118, 1119, 7, 16, 0, 0, 1119, 1120, 7, 3, 0, 0, 1120, 1121,
7, 7, 0, 0, 1121, 1122, 7, 6, 0, 0, 1122, 1123, 7, 7, 0, 0, 1123, 1124,
7, 18, 0, 0, 1124, 248, 1, 0, 0, 0, 1125, 1126, 7, 3, 0, 0, 1126, 1127,
7, 6, 0, 0, 1127, 1128, 7, 18, 0, 0, 1128, 1129, 7, 15, 0, 0, 1129, 1130,
7, 4, 0, 0, 1130, 250, 1, 0, 0, 0, 1131, 1132, 7, 3, 0, 0, 1132, 1133,
7, 2, 0, 0, 1133, 1134, 7, 11, 0, 0, 1134, 1135, 7, 11, 0, 0, 1135, 1136,
7, 1, 0, 0, 1136, 1137, 7, 0, 0, 0, 1137, 1138, 7, 5, 0, 0, 1138, 1139,
7, 20, 0, 0, 1139, 252, 1, 0, 0, 0, 1140, 1141, 7, 3, 0, 0, 1141, 1142,
7, 2, 0, 0, 1142, 1143, 7, 19, 0, 0, 1143, 254, 1, 0, 0, 0, 1144, 1145,
7, 3, 0, 0, 1145, 1146, 7, 2, 0, 0, 1146, 1147, 7, 19, 0, 0, 1147, 1148,
7, 14, 0, 0, 1148, 256, 1, 0, 0, 0, 1149, 1150, 7, 14, 0, 0, 1150, 1151,
7, 0, 0, 0, 1151, 1152, 7, 23, 0, 0, 1152, 1153, 7, 10, 0, 0, 1153, 1154,
7, 21, 0, 0, 1154, 1155, 7, 2, 0, 0, 1155, 1156, 7, 6, 0, 0, 1156, 1157,
7, 7, 0, 0, 1157, 1158, 7, 4, 0, 0, 1158, 258, 1, 0, 0, 0, 1159, 1160,
7, 14, 0, 0, 1160, 1161, 7, 10, 0, 0, 1161, 1162, 7, 11, 0, 0, 1162, 1163,
7, 10, 0, 0, 1163, 1164, 7, 5, 0, 0, 1164, 1165, 7, 4, 0, 0, 1165, 260,
1, 0, 0, 0, 1166, 1167, 7, 14, 0, 0, 1167, 1168, 7, 10, 0, 0, 1168, 1169,
7, 4, 0, 0, 1169, 262, 1, 0, 0, 0, 1170, 1171, 7, 4, 0, 0, 1171, 1172,
7, 0, 0, 0, 1172, 1173, 7, 1, 0, 0, 1173, 1174, 7, 11, 0, 0, 1174, 1175,
7, 10, 0, 0, 1175, 264, 1, 0, 0, 0, 1176, 1177, 7, 4, 0, 0, 1177, 1178,
7, 10, 0, 0, 1178, 1179, 7, 17, 0, 0, 1179, 1180, 7, 21, 0, 0, 1180, 266,
1, 0, 0, 0, 1181, 1182, 7, 4, 0, 0, 1182, 1183, 7, 10, 0, 0, 1183, 1184,
7, 17, 0, 0, 1184, 1185, 7, 21, 0, 0, 1185, 1186, 7, 2, 0, 0, 1186, 1187,
7, 3, 0, 0, 1187, 1188, 7, 0, 0, 0, 1188, 1189, 7, 3, 0, 0, 1189, 1190,
7, 12, 0, 0, 1190, 268, 1, 0, 0, 0, 1191, 1192, 7, 4, 0, 0, 1192, 1193,
7, 15, 0, 0, 1193, 1194, 7, 10, 0, 0, 1194, 1195, 7, 7, 0, 0, 1195, 270,
1, 0, 0, 0, 1196, 1197, 7, 4, 0, 0, 1197, 1198, 7, 2, 0, 0, 1198, 272,
1, 0, 0, 0, 1199, 1200, 7, 4, 0, 0, 1200, 1201, 7, 3, 0, 0, 1201, 1202,
7, 0, 0, 0, 1202, 1203, 7, 7, 0, 0, 1203, 1204, 7, 14, 0, 0, 1204, 1205,
7, 0, 0, 0, 1205, 1206, 7, 5, 0, 0, 1206, 1207, 7, 4, 0, 0, 1207, 1208,
7, 6, 0, 0, 1208, 1209, 7, 2, 0, 0, 1209, 1210, 7, 7, 0, 0, 1210, 274,
1, 0, 0, 0, 1211, 1212, 7, 4, 0, 0, 1212, 1213, 7, 3, 0, 0, 1213, 1214,
7, 6, 0, 0, 1214, 1215, 7, 18, 0, 0, 1215, 1216, 7, 18, 0, 0, 1216, 1217,
7, 10, 0, 0, 1217, 1218, 7, 3, 0, 0, 1218, 276, 1, 0, 0, 0, 1219, 1220,
7, 16, 0, 0, 1220, 1221, 7, 7, 0, 0, 1221, 1222, 7, 6, 0, 0, 1222, 1223,
7, 2, 0, 0, 1223, 1224, 7, 7, 0, 0, 1224, 278, 1, 0, 0, 0, 1225, 1226,
7, 16, 0, 0, 1226, 1227, 7, 7, 0, 0, 1227, 1228, 7, 6, 0, 0, 1228, 1229,
7, 25, 0, 0, 1229, 1230, 7, 16, 0, 0, 1230, 1231, 7, 10, 0, 0, 1231, 280,
1, 0, 0, 0, 1232, 1233, 7, 16, 0, 0, 1233, 1234, 7, 21, 0, 0, 1234, 1235,
7, 8, 0, 0, 1235, 1236, 7, 0, 0, 0, 1236, 1237, 7, 4, 0, 0, 1237, 1238,
7, 10, 0, 0, 1238, 282, 1, 0, 0, 0, 1239, 1240, 7, 16, 0, 0, 1240, 1241,
7, 14, 0, 0, 1241, 1242, 7, 6, 0, 0, 1242, 1243, 7, 7, 0, 0, 1243, 1244,
7, 18, 0, 0, 1244, 284, 1, 0, 0, 0, 1245, 1246, 7, 23, 0, 0, 1246, 1247,
7, 0, 0, 0, 1247, 1248, 7, 5, 0, 0, 1248, 1249, 7, 16, 0, 0, 1249, 1250,
7, 16, 0, 0, 1250, 1251, 7, 17, 0, 0, 1251, 286, 1, 0, 0, 0, 1252, 1253,
7, 23, 0, 0, 1253, 1254, 7, 0, 0, 0, 1254, 1255, 7, 11, 0, 0, 1255, 1256,
7, 16, 0, 0, 1256, 1257, 7, 10, 0, 0, 1257, 1258, 7, 14, 0, 0, 1258, 288,
1, 0, 0, 0, 1259, 1260, 7, 23, 0, 0, 1260, 1261, 7, 6, 0, 0, 1261, 1262,
7, 10, 0, 0, 1262, 1263, 7, 19, 0, 0, 1263, 290, 1, 0, 0, 0, 1264, 1265,
7, 23, 0, 0, 1265, 1266, 7, 6, 0, 0, 1266, 1267, 7, 3, 0, 0, 1267, 1268,
7, 4, 0, 0, 1268, 1269, 7, 16, 0, 0, 1269, 1270, 7, 0, 0, 0, 1270, 1271,
7, 11, 0, 0, 1271, 292, 1, 0, 0, 0, 1272, 1273, 7, 19, 0, 0, 1273, 1274,
7, 15, 0, 0, 1274, 1275, 7, 10, 0, 0, 1275, 1276, 7, 7, 0, 0, 1276, 294,
1, 0, 0, 0, 1277, 1278, 7, 19, 0, 0, 1278, 1279, 7, 15, 0, 0, 1279, 1280,
7, 10, 0, 0, 1280, 1281, 7, 3, 0, 0, 1281, 1282, 7, 10, 0, 0, 1282, 296,
1, 0, 0, 0, 1283, 1284, 7, 19, 0, 0, 1284, 1285, 7, 6, 0, 0, 1285, 1286,
7, 4, 0, 0, 1286, 1287, 7, 15, 0, 0, 1287, 298, 1, 0, 0, 0, 1288, 1289,
7, 19, 0, 0, 1289, 1290, 7, 6, 0, 0, 1290, 1291, 7, 4, 0, 0, 1291, 1292,
7, 15, 0, 0, 1292, 1293, 7, 2, 0, 0, 1293, 1294, 7, 16, 0, 0, 1294, 1295,
7, 4, 0, 0, 1295, 300, 1, 0, 0, 0, 1296, 1297, 7, 9, 0, 0, 1297, 1298,
7, 6, 0, 0, 1298, 1299, 7, 3, 0, 0, 1299, 1300, 7, 14, 0, 0, 1300, 1301,
7, 4, 0, 0, 1301, 1302, 5, 95, 0, 0, 1302, 1303, 7, 23, 0, 0, 1303, 1304,
7, 0, 0, 0, 1304, 1305, 7, 11, 0, 0, 1305, 1306, 7, 16, 0, 0, 1306, 1307,
7, 10, 0, 0, 1307, 302, 1, 0, 0, 0, 1308, 1309, 7, 2, 0, 0, 1309, 1310,
7, 23, 0, 0, 1310, 1311, 7, 10, 0, 0, 1311, 1312, 7, 3, 0, 0, 1312, 304,
1, 0, 0, 0, 1313, 1314, 7, 21, 0, 0, 1314, 1315, 7, 0, 0, 0, 1315, 1316,
7, 3, 0, 0, 1316, 1317, 7, 4, 0, 0, 1317, 1318, 7, 6, 0, 0, 1318, 1319,
7, 4, 0, 0, 1319, 1320, 7, 6, 0, 0, 1320, 1321, 7, 2, 0, 0, 1321, 1322,
7, 7, 0, 0, 1322, 306, 1, 0, 0, 0, 1323, 1324, 7, 3, 0, 0, 1324, 1325,
7, 0, 0, 0, 1325, 1326, 7, 7, 0, 0, 1326, 1327, 7, 18, 0, 0, 1327, 1328,
7, 10, 0, 0, 1328, 308, 1, 0, 0, 0, 1329, 1330, 7, 21, 0, 0, 1330, 1331,
7, 3, 0, 0, 1331, 1332, 7, 10, 0, 0, 1332, 1333, 7, 5, 0, 0, 1333, 1334,
7, 10, 0, 0, 1334, 1335, 7, 8, 0, 0, 1335, 1336, 7, 6, 0, 0, 1336, 1337,
7, 7, 0, 0, 1337, 1338, 7, 18, 0, 0, 1338, 310, 1, 0, 0, 0, 1339, 1340,
7, 16, 0, 0, 1340, 1341, 7, 7, 0, 0, 1341, 1342, 7, 1, 0, 0, 1342, 1343,
7, 2, 0, 0, 1343, 1344, 7, 16, 0, 0, 1344, 1345, 7, 7, 0, 0, 1345, 1346,
7, 8, 0, 0, 1346, 1347, 7, 10, 0, 0, 1347, 1348, 7, 8, 0, 0, 1348, 312,
1, 0, 0, 0, 1349, 1350, 7, 5, 0, 0, 1350, 1351, 7, 16, 0, 0, 1351, 1352,
7, 3, 0, 0, 1352, 1353, 7, 3, 0, 0, 1353, 1354, 7, 10, 0, 0, 1354, 1355,
7, 7, 0, 0, 1355, 1356, 7, 4, 0, 0, 1356, 314, 1, 0, 0, 0, 1357, 1358,
7, 9, 0, 0, 1358, 1359, 7, 2, 0, 0, 1359, 1360, 7, 11, 0, 0, 1360, 1361,
7, 11, 0, 0, 1361, 1362, 7, 2, 0, 0, 1362, 1363, 7, 19, 0, 0, 1363, 1364,
7, 6, 0, 0, 1364, 1365, 7, 7, 0, 0, 1365, 1366, 7, 18, 0, 0, 1366, 316,
1, 0, 0, 0, 1367, 1368, 7, 5, 0, 0, 1368, 1369, 7, 16, 0, 0, 1369, 1370,
7, 17, 0, 0, 1370, 1371, 7, 10, 0, 0, 1371, 1372, 5, 95, 0, 0, 1372, 1373,
7, 8, 0, 0, 1373, 1374, 7, 6, 0, 0, 1374, 1375, 7, 14, 0, 0, 1375, 1376,
7, 4, 0, 0, 1376, 318, 1, 0, 0, 0, 1377, 1378, 7, 8, 0, 0, 1378, 1379,
7, 10, 0, 0, 1379, 1380, 7, 7, 0, 0, 1380, 1381, 7, 14, 0, 0, 1381, 1382,
7, 10, 0, 0, 1382, 1383, 5, 95, 0, 0, 1383, 1384, 7, 3, 0, 0, 1384, 1385,
7, 0, 0, 0, 1385, 1386, 7, 7, 0, 0, 1386, 1387, 7, 20, 0, 0, 1387, 320,
1, 0, 0, 0, 1388, 1389, 7, 11, 0, 0, 1389, 1390, 7, 0, 0, 0, 1390, 1391,
7, 18, 0, 0, 1391, 322, 1, 0, 0, 0, 1392, 1393, 7, 11, 0, 0, 1393, 1394,
7, 0, 0, 0, 1394, 1395, 7, 14, 0, 0, 1395, 1396, 7, 4, 0, 0, 1396, 1397,
5, 95, 0, 0, 1397, 1398, 7, 23, 0, 0, 1398, 1399, 7, 0, 0, 0, 1399, 1400,
7, 11, 0, 0, 1400, 1401, 7, 16, 0, 0, 1401, 1402, 7, 10, 0, 0, 1402, 324,
1, 0, 0, 0, 1403, 1404, 7, 11, 0, 0, 1404, 1405, 7, 10, 0, 0, 1405, 1406,
7, 0, 0, 0, 1406, 1407, 7, 8, 0, 0, 1407, 326, 1, 0, 0, 0, 1408, 1409,
7, 7, 0, 0, 1409, 1410, 7, 4, 0, 0, 1410, 1411, 7, 15, 0, 0, 1411, 1412,
5, 95, 0, 0, 1412, 1413, 7, 23, 0, 0, 1413, 1414, 7, 0, 0, 0, 1414, 1415,
7, 11, 0, 0, 1415, 1416, 7, 16, 0, 0, 1416, 1417, 7, 10, 0, 0, 1417, 328,
1, 0, 0, 0, 1418, 1419, 7, 7, 0, 0, 1419, 1420, 7, 4, 0, 0, 1420, 1421,
7, 6, 0, 0, 1421, 1422, 7, 11, 0, 0, 1422, 1423, 7, 10, 0, 0, 1423, 330,
1, 0, 0, 0, 1424, 1425, 7, 21, 0, 0, 1425, 1426, 7, 10, 0, 0, 1426, 1427,
7, 3, 0, 0, 1427, 1428, 7, 5, 0, 0, 1428, 1429, 7, 10, 0, 0, 1429, 1430,
7, 7, 0, 0, 1430, 1431, 7, 4, 0, 0, 1431, 1432, 5, 95, 0, 0, 1432, 1433,
7, 3, 0, 0, 1433, 1434, 7, 0, 0, 0, 1434, 1435, 7, 7, 0, 0, 1435, 1436,
7, 20, 0, 0, 1436, 332, 1, 0, 0, 0, 1437, 1438, 7, 3, 0, 0, 1438, 1439,
7, 0, 0, 0, 1439, 1440, 7, 7, 0, 0, 1440, 1441, 7, 20, 0, 0, 1441, 334,
1, 0, 0, 0, 1442, 1443, 7, 3, 0, 0, 1443, 1444, 7, 2, 0, 0, 1444, 1445,
7, 19, 0, 0, 1445, 1446, 5, 95, 0, 0, 1446, 1447, 7, 7, 0, 0, 1447, 1448,
7, 16, 0, 0, 1448, 1449, 7, 17, 0, 0, 1449, 1450, 7, 1, 0, 0, 1450, 1451,
7, 10, 0, 0, 1451, 1452, 7, 3, 0, 0, 1452, 336, 1, 0, 0, 0, 1453, 1454,
7, 18, 0, 0, 1454, 1455, 7, 10, 0, 0, 1455, 1456, 7, 7, 0, 0, 1456, 1457,
7, 10, 0, 0, 1457, 1458, 7, 3, 0, 0, 1458, 1459, 7, 0, 0, 0, 1459, 1460,
7, 4, 0, 0, 1460, 1461, 7, 10, 0, 0, 1461, 1462, 7, 8, 0, 0, 1462, 338,
1, 0, 0, 0, 1463, 1464, 7, 0, 0, 0, 1464, 1465, 7, 11, 0, 0, 1465, 1466,
7, 19, 0, 0, 1466, 1467, 7, 0, 0, 0, 1467, 1468, 7, 12, 0, 0, 1468, 1469,
7, 14, 0, 0, 1469, 340, 1, 0, 0, 0, 1470, 1471, 7, 14, 0, 0, 1471, 1472,
7, 4, 0, 0, 1472, 1473, 7, 2, 0, 0, 1473, 1474, 7, 3, 0, 0, 1474, 1475,
7, 10, 0, 0, 1475, 1476, 7, 8, 0, 0, 1476, 342, 1, 0, 0, 0, 1477, 1478,
7, 4, 0, 0, 1478, 1479, 7, 3, 0, 0, 1479, 1480, 7, 16, 0, 0, 1480, 1481,
7, 10, 0, 0, 1481, 344, 1, 0, 0, 0, 1482, 1483, 7, 9, 0, 0, 1483, 1484,
7, 0, 0, 0, 1484, 1485, 7, 11, 0, 0, 1485, 1486, 7, 14, 0, 0, 1486, 1487,
7, 10, 0, 0, 1487, 346, 1, 0, 0, 0, 1488, 1489, 7, 19, 0, 0, 1489, 1490,
7, 6, 0, 0, 1490, 1491, 7, 7, 0, 0, 1491, 1492, 7, 8, 0, 0, 1492, 1493,
7, 2, 0, 0, 1493, 1494, 7, 19, 0, 0, 1494, 348, 1, 0, 0, 0, 1495, 1496,
7, 7, 0, 0, 1496, 1497, 7, 16, 0, 0, 1497, 1498, 7, 11, 0, 0, 1498, 1499,
7, 11, 0, 0, 1499, 1500, 7, 14, 0, 0, 1500, 350, 1, 0, 0, 0, 1501, 1502,
7, 9, 0, 0, 1502, 1503, 7, 6, 0, 0, 1503, 1504, 7, 3, 0, 0, 1504, 1505,
7, 14, 0, 0, 1505, 1506, 7, 4, 0, 0, 1506, 352, 1, 0, 0, 0, 1507, 1508,
7, 11, 0, 0, 1508, 1509, 7, 0, 0, 0, 1509, 1510, 7, 14, 0, 0, 1510, 1511,
7, 4, 0, 0, 1511, 354, 1, 0, 0, 0, 1512, 1513, 7, 9, 0, 0, 1513, 1514,
7, 6, 0, 0, 1514, 1515, 7, 11, 0, 0, 1515, 1516, 7, 4, 0, 0, 1516, 1517,
7, 10, 0, 0, 1517, 1518, 7, 3, 0, 0, 1518, 356, 1, 0, 0, 0, 1519, 1520,
7, 18, 0, 0, 1520, 1521, 7, 3, 0, 0, 1521, 1522, 7, 2, 0, 0, 1522, 1523,
7, 16, 0, 0, 1523, 1524, 7, 21, 0, 0, 1524, 1525, 7, 14, 0, 0, 1525, 358,
1, 0, 0, 0, 1526, 1527, 7, 10, 0, 0, 1527, 1528, 7, 22, 0, 0, 1528, 1529,
7, 5, 0, 0, 1529, 1530, 7, 11, 0, 0, 1530, 1531, 7, 16, 0, 0, 1531, 1532,
7, 8, 0, 0, 1532, 1533, 7, 10, 0, 0, 1533, 360, 1, 0, 0, 0, 1534, 1535,
7, 4, 0, 0, 1535, 1536, 7, 6, 0, 0, 1536, 1537, 7, 10, 0, 0, 1537, 1538,
7, 14, 0, 0, 1538, 362, 1, 0, 0, 0, 1539, 1540, 7, 2, 0, 0, 1540, 1541,
7, 4, 0, 0, 1541, 1542, 7, 15, 0, 0, 1542, 1543, 7, 10, 0, 0, 1543, 1544,
7, 3, 0, 0, 1544, 1545, 7, 14, 0, 0, 1545, 364, 1, 0, 0, 0, 1546, 1547,
7, 8, 0, 0, 1547, 1548, 7, 2, 0, 0, 1548, 366, 1, 0, 0, 0, 1549, 1550,
7, 7, 0, 0, 1550, 1551, 7, 2, 0, 0, 1551, 1552, 7, 4, 0, 0, 1552, 1553,
7, 15, 0, 0, 1553, 1554, 7, 6, 0, 0, 1554, 1555, 7, 7, 0, 0, 1555, 1556,
7, 18, 0, 0, 1556, 368, 1, 0, 0, 0, 1557, 1563, 5, 34, 0, 0, 1558, 1562,
8, 26, 0, 0, 1559, 1560, 5, 34, 0, 0, 1560, 1562, 5, 34, 0, 0, 1561, 1558,
1, 0, 0, 0, 1561, 1559, 1, 0, 0, 0, 1562, 1565, 1, 0, 0, 0, 1563, 1561,
1, 0, 0, 0, 1563, 1564, 1, 0, 0, 0, 1564, 1566, 1, 0, 0, 0, 1565, 1563,
1, 0, 0, 0, 1566, 1593, 5, 34, 0, 0, 1567, 1573, 5, 96, 0, 0, 1568, 1572,
8, 27, 0, 0, 1569, 1570, 5, 96, 0, 0, 1570, 1572, 5, 96, 0, 0, 1571, 1568,
1, 0, 0, 0, 1571, 1569, 1, 0, 0, 0, 1572, 1575, 1, 0, 0, 0, 1573, 1571,
1, 0, 0, 0, 1573, 1574, 1, 0, 0, 0, 1574, 1576, 1, 0, 0, 0, 1575, 1573,
1, 0, 0, 0, 1576, 1593, 5, 96, 0, 0, 1577, 1581, 5, 91, 0, 0, 1578, 1580,
8, 28, 0, 0, 1579, 1578, 1, 0, 0, 0, 1580, 1583, 1, 0, 0, 0, 1581, 1579,
1, 0, 0, 0, 1581, 1582, 1, 0, 0, 0, 1582, 1584, 1, 0, 0, 0, 1583, 1581,
1, 0, 0, 0, 1584, 1593, 5, 93, 0, 0, 1585, 1589, 7, 29, 0, 0, 1586, 1588,
7, 30, 0, 0, 1587, 1586, 1, 0, 0, 0, 1588, 1591, 1, 0, 0, 0, 1589, 1587,
1, 0, 0, 0, 1589, 1590, 1, 0, 0, 0, 1590, 1593, 1, 0, 0, 0, 1591, 1589,
1, 0, 0, 0, 1592, 1557, 1, 0, 0, 0, 1592, 1567, 1, 0, 0, 0, 1592, 1577,
1, 0, 0, 0, 1592, 1585, 1, 0, 0, 0, 1593, 370, 1, 0, 0, 0, 1594, 1596,
3, 389, 194, 0, 1595, 1594, 1, 0, 0, 0, 1596, 1597, 1, 0, 0, 0, 1597, 1595,
1, 0, 0, 0, 1597, 1598, 1, 0, 0, 0, 1598, 1606, 1, 0, 0, 0, 1599, 1603,
5, 46, 0, 0, 1600, 1602, 3, 389, 194, 0, 1601, 1600, 1, 0, 0, 0, 1602,
1605, 1, 0, 0, 0, 1603, 1601, 1, 0, 0, 0, 1603, 1604, 1, 0, 0, 0, 1604,
1607, 1, 0, 0, 0, 1605, 1603, 1, 0, 0, 0, 1606, 1599, 1, 0, 0, 0, 1606,
1607, 1, 0, 0, 0, 1607, 1615, 1, 0, 0, 0, 1608, 1610, 5, 46, 0, 0, 1609,
1611, 3, 389, 194, 0, 1610, 1609, 1, 0, 0, 0, 1611, 1612, 1, 0, 0, 0, 1612,
1610, 1, 0, 0, 0, 1612, 1613, 1, 0, 0, 0, 1613, 1615, 1, 0, 0, 0, 1614,
1595, 1, 0, 0, 0, 1614, 1608, 1, 0, 0, 0, 1615, 1625, 1, 0, 0, 0, 1616,
1618, 7, 10, 0, 0, 1617, 1619, 7, 31, 0, 0, 1618, 1617, 1, 0, 0, 0, 1618,
1619, 1, 0, 0, 0, 1619, 1621, 1, 0, 0, 0, 1620, 1622, 3, 389, 194, 0, 1621,
1620, 1, 0, 0, 0, 1622, 1623, 1, 0, 0, 0, 1623, 1621, 1, 0, 0, 0, 1623,
1624, 1, 0, 0, 0, 1624, 1626, 1, 0, 0, 0, 1625, 1616, 1, 0, 0, 0, 1625,
1626, 1, 0, 0, 0, 1626, 1636, 1, 0, 0, 0, 1627, 1628, 5, 48, 0, 0, 1628,
1629, 7, 22, 0, 0, 1629, 1631, 1, 0, 0, 0, 1630, 1632, 3, 387, 193, 0,
1631, 1630, 1, 0, 0, 0, 1632, 1633, 1, 0, 0, 0, 1633, 1631, 1, 0, 0, 0,
1633, 1634, 1, 0, 0, 0, 1634, 1636, 1, 0, 0, 0, 1635, 1614, 1, 0, 0, 0,
1635, 1627, 1, 0, 0, 0, 1636, 372, 1, 0, 0, 0, 1637, 1641, 5, 63, 0, 0,
1638, 1640, 3, 389, 194, 0, 1639, 1638, 1, 0, 0, 0, 1640, 1643, 1, 0, 0,
0, 1641, 1639, 1, 0, 0, 0, 1641, 1642, 1, 0, 0, 0, 1642, 1647, 1, 0, 0,
0, 1643, 1641, 1, 0, 0, 0, 1644, 1645, 7, 32, 0, 0, 1645, 1647, 3, 369,
184, 0, 1646, 1637, 1, 0, 0, 0, 1646, 1644, 1, 0, 0, 0, 1647, 374, 1, 0,
0, 0, 1648, 1654, 5, 39, 0, 0, 1649, 1653, 8, 33, 0, 0, 1650, 1651, 5,
39, 0, 0, 1651, 1653, 5, 39, 0, 0, 1652, 1649, 1, 0, 0, 0, 1652, 1650,
1, 0, 0, 0, 1653, 1656, 1, 0, 0, 0, 1654, 1652, 1, 0, 0, 0, 1654, 1655,
1, 0, 0, 0, 1655, 1657, 1, 0, 0, 0, 1656, 1654, 1, 0, 0, 0, 1657, 1658,
5, 39, 0, 0, 1658, 376, 1, 0, 0, 0, 1659, 1660, 7, 22, 0, 0, 1660, 1661,
3, 375, 187, 0, 1661, 378, 1, 0, 0, 0, 1662, 1663, 5, 45, 0, 0, 1663, 1664,
5, 45, 0, 0, 1664, 1668, 1, 0, 0, 0, 1665, 1667, 8, 34, 0, 0, 1666, 1665,
1, 0, 0, 0, 1667, 1670, 1, 0, 0, 0, 1668, 1666, 1, 0, 0, 0, 1668, 1669,
1, 0, 0, 0, 1669, 1676, 1, 0, 0, 0, 1670, 1668, 1, 0, 0, 0, 1671, 1673,
5, 13, 0, 0, 1672, 1671, 1, 0, 0, 0, 1672, 1673, 1, 0, 0, 0, 1673, 1674,
1, 0, 0, 0, 1674, 1677, 5, 10, 0, 0, 1675, 1677, 5, 0, 0, 1, 1676, 1672,
1, 0, 0, 0, 1676, 1675, 1, 0, 0, 0, 1677, 1678, 1, 0, 0, 0, 1678, 1679,
6, 189, 0, 0, 1679, 380, 1, 0, 0, 0, 1680, 1681, 5, 47, 0, 0, 1681, 1682,
5, 42, 0, 0, 1682, 1686, 1, 0, 0, 0, 1683, 1685, 9, 0, 0, 0, 1684, 1683,
1, 0, 0, 0, 1685, 1688, 1, 0, 0, 0, 1686, 1687, 1, 0, 0, 0, 1686, 1684,
1, 0, 0, 0, 1687, 1689, 1, 0, 0, 0, 1688, 1686, 1, 0, 0, 0, 1689, 1690,
5, 42, 0, 0, 1690, 1691, 5, 47, 0, 0, 1691, 1692, 1, 0, 0, 0, 1692, 1693,
6, 190, 0, 0, 1693, 382, 1, 0, 0, 0, 1694, 1695, 7, 35, 0, 0, 1695, 1696,
1, 0, 0, 0, 1696, 1697, 6, 191, 0, 0, 1697, 384, 1, 0, 0, 0, 1698, 1699,
9, 0, 0, 0, 1699, 386, 1, 0, 0, 0, 1700, 1701, 7, 36, 0, 0, 1701, 388,
1, 0, 0, 0, 1702, 1703, 7, 37, 0, 0, 1703, 390, 1, 0, 0, 0, 26, 0, 1561,
1563, 1571, 1573, 1581, 1589, 1592, 1597, 1603, 1606, 1612, 1614, 1618,
1623, 1625, 1633, 1635, 1641, 1646, 1652, 1654, 1668, 1672, 1676, 1686,
1, 0, 1, 0,
}
deserializer := antlr.NewATNDeserializer(nil)
staticData.atn = deserializer.Deserialize(staticData.serializedATN)
atn := staticData.atn
staticData.decisionToDFA = make([]*antlr.DFA, len(atn.DecisionToState))
decisionToDFA := staticData.decisionToDFA
for index, state := range atn.DecisionToState {
decisionToDFA[index] = antlr.NewDFA(state, index)
}
}
// LexerInit initializes any static state used to implement Lexer. By default the
// static state used to implement the lexer is lazily initialized during the first call to
// NewLexer(). You can call this function if you wish to initialize the static state ahead
// of time.
func LexerInit() {
staticData := &lexerLexerStaticData
staticData.once.Do(lexerLexerInit)
}
// NewLexer produces a new lexer instance for the optional input antlr.CharStream.
func NewLexer(input antlr.CharStream) *Lexer {
LexerInit()
l := new(Lexer)
l.BaseLexer = antlr.NewBaseLexer(input)
staticData := &lexerLexerStaticData
l.Interpreter = antlr.NewLexerATNSimulator(l, staticData.atn, staticData.decisionToDFA, staticData.predictionContextCache)
l.channelNames = staticData.channelNames
l.modeNames = staticData.modeNames
l.RuleNames = staticData.ruleNames
l.LiteralNames = staticData.literalNames
l.SymbolicNames = staticData.symbolicNames
l.GrammarFileName = "Lexer.g4"
// TODO: l.EOF = antlr.TokenEOF
return l
}
// Lexer tokens.
const (
LexerSCOL = 1
LexerDOT = 2
LexerOPEN_PAR = 3
LexerCLOSE_PAR = 4
LexerCOMMA = 5
LexerASSIGN = 6
LexerSTAR = 7
LexerPLUS = 8
LexerMINUS = 9
LexerTILDE = 10
LexerPIPE2 = 11
LexerDIV = 12
LexerMOD = 13
LexerLT2 = 14
LexerGT2 = 15
LexerAMP = 16
LexerPIPE = 17
LexerLT = 18
LexerLT_EQ = 19
LexerGT = 20
LexerGT_EQ = 21
LexerEQ = 22
LexerNOT_EQ1 = 23
LexerNOT_EQ2 = 24
LexerABORT_ = 25
LexerACTION_ = 26
LexerADD_ = 27
LexerAFTER_ = 28
LexerALL_ = 29
LexerALTER_ = 30
LexerANALYZE_ = 31
LexerAND_ = 32
LexerAS_ = 33
LexerASC_ = 34
LexerATTACH_ = 35
LexerAUTOINCREMENT_ = 36
LexerBEFORE_ = 37
LexerBEGIN_ = 38
LexerBETWEEN_ = 39
LexerBY_ = 40
LexerCASCADE_ = 41
LexerCASE_ = 42
LexerCAST_ = 43
LexerCHECK_ = 44
LexerCOLLATE_ = 45
LexerCOLUMN_ = 46
LexerCOMMIT_ = 47
LexerCONFLICT_ = 48
LexerCONSTRAINT_ = 49
LexerCREATE_ = 50
LexerCROSS_ = 51
LexerCURRENT_DATE_ = 52
LexerCURRENT_TIME_ = 53
LexerCURRENT_TIMESTAMP_ = 54
LexerDATABASE_ = 55
LexerDEFAULT_ = 56
LexerDEFERRABLE_ = 57
LexerDEFERRED_ = 58
LexerDELETE_ = 59
LexerDESC_ = 60
LexerDETACH_ = 61
LexerDISTINCT_ = 62
LexerDROP_ = 63
LexerEACH_ = 64
LexerELSE_ = 65
LexerEND_ = 66
LexerESCAPE_ = 67
LexerEXCEPT_ = 68
LexerEXCLUSIVE_ = 69
LexerEXISTS_ = 70
LexerEXPLAIN_ = 71
LexerFAIL_ = 72
LexerFOR_ = 73
LexerFOREIGN_ = 74
LexerFROM_ = 75
LexerFULL_ = 76
LexerGLOB_ = 77
LexerGROUP_ = 78
LexerHAVING_ = 79
LexerIF_ = 80
LexerIGNORE_ = 81
LexerIMMEDIATE_ = 82
LexerIN_ = 83
LexerINDEX_ = 84
LexerINDEXED_ = 85
LexerINITIALLY_ = 86
LexerINNER_ = 87
LexerINSERT_ = 88
LexerINSTEAD_ = 89
LexerINTERSECT_ = 90
LexerINTO_ = 91
LexerIS_ = 92
LexerISNULL_ = 93
LexerJOIN_ = 94
LexerKEY_ = 95
LexerLEFT_ = 96
LexerLIKE_ = 97
LexerLIMIT_ = 98
LexerMATCH_ = 99
LexerNATURAL_ = 100
LexerNO_ = 101
LexerNOT_ = 102
LexerNOTNULL_ = 103
LexerNULL_ = 104
LexerOF_ = 105
LexerOFFSET_ = 106
LexerON_ = 107
LexerOR_ = 108
LexerORDER_ = 109
LexerOUTER_ = 110
LexerPLAN_ = 111
LexerPRAGMA_ = 112
LexerPRIMARY_ = 113
LexerQUERY_ = 114
LexerRAISE_ = 115
LexerRECURSIVE_ = 116
LexerREFERENCES_ = 117
LexerREGEXP_ = 118
LexerREINDEX_ = 119
LexerRELEASE_ = 120
LexerRENAME_ = 121
LexerREPLACE_ = 122
LexerRESTRICT_ = 123
LexerRETURNING_ = 124
LexerRIGHT_ = 125
LexerROLLBACK_ = 126
LexerROW_ = 127
LexerROWS_ = 128
LexerSAVEPOINT_ = 129
LexerSELECT_ = 130
LexerSET_ = 131
LexerTABLE_ = 132
LexerTEMP_ = 133
LexerTEMPORARY_ = 134
LexerTHEN_ = 135
LexerTO_ = 136
LexerTRANSACTION_ = 137
LexerTRIGGER_ = 138
LexerUNION_ = 139
LexerUNIQUE_ = 140
LexerUPDATE_ = 141
LexerUSING_ = 142
LexerVACUUM_ = 143
LexerVALUES_ = 144
LexerVIEW_ = 145
LexerVIRTUAL_ = 146
LexerWHEN_ = 147
LexerWHERE_ = 148
LexerWITH_ = 149
LexerWITHOUT_ = 150
LexerFIRST_VALUE_ = 151
LexerOVER_ = 152
LexerPARTITION_ = 153
LexerRANGE_ = 154
LexerPRECEDING_ = 155
LexerUNBOUNDED_ = 156
LexerCURRENT_ = 157
LexerFOLLOWING_ = 158
LexerCUME_DIST_ = 159
LexerDENSE_RANK_ = 160
LexerLAG_ = 161
LexerLAST_VALUE_ = 162
LexerLEAD_ = 163
LexerNTH_VALUE_ = 164
LexerNTILE_ = 165
LexerPERCENT_RANK_ = 166
LexerRANK_ = 167
LexerROW_NUMBER_ = 168
LexerGENERATED_ = 169
LexerALWAYS_ = 170
LexerSTORED_ = 171
LexerTRUE_ = 172
LexerFALSE_ = 173
LexerWINDOW_ = 174
LexerNULLS_ = 175
LexerFIRST_ = 176
LexerLAST_ = 177
LexerFILTER_ = 178
LexerGROUPS_ = 179
LexerEXCLUDE_ = 180
LexerTIES_ = 181
LexerOTHERS_ = 182
LexerDO_ = 183
LexerNOTHING_ = 184
LexerIDENTIFIER = 185
LexerNUMERIC_LITERAL = 186
LexerBIND_PARAMETER = 187
LexerSTRING_LITERAL = 188
LexerBLOB_LITERAL = 189
LexerSINGLE_LINE_COMMENT = 190
LexerMULTILINE_COMMENT = 191
LexerSPACES = 192
LexerUNEXPECTED_CHAR = 193
)
atlas-0.7.2/cmd/atlas/internal/sqlparse/sqliteparse/parser.go 0000664 0000000 0000000 00002531350 14314555116 0024336 0 ustar 00root root 0000000 0000000 // Code generated from Parser.g4 by ANTLR 4.10.1. DO NOT EDIT.
package sqliteparse // Parser
import (
"fmt"
"strconv"
"sync"
"github.com/antlr/antlr4/runtime/Go/antlr"
)
// Suppress unused import errors
var _ = fmt.Printf
var _ = strconv.Itoa
var _ = sync.Once{}
type Parser struct {
*antlr.BaseParser
}
var parserParserStaticData struct {
once sync.Once
serializedATN []int32
literalNames []string
symbolicNames []string
ruleNames []string
predictionContextCache *antlr.PredictionContextCache
atn *antlr.ATN
decisionToDFA []*antlr.DFA
}
func parserParserInit() {
staticData := &parserParserStaticData
staticData.literalNames = []string{
"", "';'", "'.'", "'('", "')'", "','", "'='", "'*'", "'+'", "'-'", "'~'",
"'||'", "'/'", "'%'", "'<<'", "'>>'", "'&'", "'|'", "'<'", "'<='", "'>'",
"'>='", "'=='", "'!='", "'<>'", "'ABORT'", "'ACTION'", "'ADD'", "'AFTER'",
"'ALL'", "'ALTER'", "'ANALYZE'", "'AND'", "'AS'", "'ASC'", "'ATTACH'",
"'AUTOINCREMENT'", "'BEFORE'", "'BEGIN'", "'BETWEEN'", "'BY'", "'CASCADE'",
"'CASE'", "'CAST'", "'CHECK'", "'COLLATE'", "'COLUMN'", "'COMMIT'",
"'CONFLICT'", "'CONSTRAINT'", "'CREATE'", "'CROSS'", "'CURRENT_DATE'",
"'CURRENT_TIME'", "'CURRENT_TIMESTAMP'", "'DATABASE'", "'DEFAULT'",
"'DEFERRABLE'", "'DEFERRED'", "'DELETE'", "'DESC'", "'DETACH'", "'DISTINCT'",
"'DROP'", "'EACH'", "'ELSE'", "'END'", "'ESCAPE'", "'EXCEPT'", "'EXCLUSIVE'",
"'EXISTS'", "'EXPLAIN'", "'FAIL'", "'FOR'", "'FOREIGN'", "'FROM'", "'FULL'",
"'GLOB'", "'GROUP'", "'HAVING'", "'IF'", "'IGNORE'", "'IMMEDIATE'",
"'IN'", "'INDEX'", "'INDEXED'", "'INITIALLY'", "'INNER'", "'INSERT'",
"'INSTEAD'", "'INTERSECT'", "'INTO'", "'IS'", "'ISNULL'", "'JOIN'",
"'KEY'", "'LEFT'", "'LIKE'", "'LIMIT'", "'MATCH'", "'NATURAL'", "'NO'",
"'NOT'", "'NOTNULL'", "'NULL'", "'OF'", "'OFFSET'", "'ON'", "'OR'",
"'ORDER'", "'OUTER'", "'PLAN'", "'PRAGMA'", "'PRIMARY'", "'QUERY'",
"'RAISE'", "'RECURSIVE'", "'REFERENCES'", "'REGEXP'", "'REINDEX'", "'RELEASE'",
"'RENAME'", "'REPLACE'", "'RESTRICT'", "'RETURNING'", "'RIGHT'", "'ROLLBACK'",
"'ROW'", "'ROWS'", "'SAVEPOINT'", "'SELECT'", "'SET'", "'TABLE'", "'TEMP'",
"'TEMPORARY'", "'THEN'", "'TO'", "'TRANSACTION'", "'TRIGGER'", "'UNION'",
"'UNIQUE'", "'UPDATE'", "'USING'", "'VACUUM'", "'VALUES'", "'VIEW'",
"'VIRTUAL'", "'WHEN'", "'WHERE'", "'WITH'", "'WITHOUT'", "'FIRST_VALUE'",
"'OVER'", "'PARTITION'", "'RANGE'", "'PRECEDING'", "'UNBOUNDED'", "'CURRENT'",
"'FOLLOWING'", "'CUME_DIST'", "'DENSE_RANK'", "'LAG'", "'LAST_VALUE'",
"'LEAD'", "'NTH_VALUE'", "'NTILE'", "'PERCENT_RANK'", "'RANK'", "'ROW_NUMBER'",
"'GENERATED'", "'ALWAYS'", "'STORED'", "'TRUE'", "'FALSE'", "'WINDOW'",
"'NULLS'", "'FIRST'", "'LAST'", "'FILTER'", "'GROUPS'", "'EXCLUDE'",
"'TIES'", "'OTHERS'", "'DO'", "'NOTHING'",
}
staticData.symbolicNames = []string{
"", "SCOL", "DOT", "OPEN_PAR", "CLOSE_PAR", "COMMA", "ASSIGN", "STAR",
"PLUS", "MINUS", "TILDE", "PIPE2", "DIV", "MOD", "LT2", "GT2", "AMP",
"PIPE", "LT", "LT_EQ", "GT", "GT_EQ", "EQ", "NOT_EQ1", "NOT_EQ2", "ABORT_",
"ACTION_", "ADD_", "AFTER_", "ALL_", "ALTER_", "ANALYZE_", "AND_", "AS_",
"ASC_", "ATTACH_", "AUTOINCREMENT_", "BEFORE_", "BEGIN_", "BETWEEN_",
"BY_", "CASCADE_", "CASE_", "CAST_", "CHECK_", "COLLATE_", "COLUMN_",
"COMMIT_", "CONFLICT_", "CONSTRAINT_", "CREATE_", "CROSS_", "CURRENT_DATE_",
"CURRENT_TIME_", "CURRENT_TIMESTAMP_", "DATABASE_", "DEFAULT_", "DEFERRABLE_",
"DEFERRED_", "DELETE_", "DESC_", "DETACH_", "DISTINCT_", "DROP_", "EACH_",
"ELSE_", "END_", "ESCAPE_", "EXCEPT_", "EXCLUSIVE_", "EXISTS_", "EXPLAIN_",
"FAIL_", "FOR_", "FOREIGN_", "FROM_", "FULL_", "GLOB_", "GROUP_", "HAVING_",
"IF_", "IGNORE_", "IMMEDIATE_", "IN_", "INDEX_", "INDEXED_", "INITIALLY_",
"INNER_", "INSERT_", "INSTEAD_", "INTERSECT_", "INTO_", "IS_", "ISNULL_",
"JOIN_", "KEY_", "LEFT_", "LIKE_", "LIMIT_", "MATCH_", "NATURAL_", "NO_",
"NOT_", "NOTNULL_", "NULL_", "OF_", "OFFSET_", "ON_", "OR_", "ORDER_",
"OUTER_", "PLAN_", "PRAGMA_", "PRIMARY_", "QUERY_", "RAISE_", "RECURSIVE_",
"REFERENCES_", "REGEXP_", "REINDEX_", "RELEASE_", "RENAME_", "REPLACE_",
"RESTRICT_", "RETURNING_", "RIGHT_", "ROLLBACK_", "ROW_", "ROWS_", "SAVEPOINT_",
"SELECT_", "SET_", "TABLE_", "TEMP_", "TEMPORARY_", "THEN_", "TO_",
"TRANSACTION_", "TRIGGER_", "UNION_", "UNIQUE_", "UPDATE_", "USING_",
"VACUUM_", "VALUES_", "VIEW_", "VIRTUAL_", "WHEN_", "WHERE_", "WITH_",
"WITHOUT_", "FIRST_VALUE_", "OVER_", "PARTITION_", "RANGE_", "PRECEDING_",
"UNBOUNDED_", "CURRENT_", "FOLLOWING_", "CUME_DIST_", "DENSE_RANK_",
"LAG_", "LAST_VALUE_", "LEAD_", "NTH_VALUE_", "NTILE_", "PERCENT_RANK_",
"RANK_", "ROW_NUMBER_", "GENERATED_", "ALWAYS_", "STORED_", "TRUE_",
"FALSE_", "WINDOW_", "NULLS_", "FIRST_", "LAST_", "FILTER_", "GROUPS_",
"EXCLUDE_", "TIES_", "OTHERS_", "DO_", "NOTHING_", "IDENTIFIER", "NUMERIC_LITERAL",
"BIND_PARAMETER", "STRING_LITERAL", "BLOB_LITERAL", "SINGLE_LINE_COMMENT",
"MULTILINE_COMMENT", "SPACES", "UNEXPECTED_CHAR",
}
staticData.ruleNames = []string{
"parse", "sql_stmt_list", "sql_stmt", "alter_table_stmt", "analyze_stmt",
"attach_stmt", "begin_stmt", "commit_stmt", "rollback_stmt", "savepoint_stmt",
"release_stmt", "create_index_stmt", "indexed_column", "create_table_stmt",
"column_def", "type_name", "column_constraint", "signed_number", "table_constraint",
"foreign_key_clause", "conflict_clause", "create_trigger_stmt", "create_view_stmt",
"create_virtual_table_stmt", "with_clause", "cte_table_name", "recursive_cte",
"common_table_expression", "delete_stmt", "delete_stmt_limited", "detach_stmt",
"drop_stmt", "expr", "raise_function", "literal_value", "insert_stmt",
"returning_clause", "upsert_clause", "pragma_stmt", "pragma_value",
"reindex_stmt", "select_stmt", "join_clause", "select_core", "factored_select_stmt",
"simple_select_stmt", "compound_select_stmt", "table_or_subquery", "result_column",
"join_operator", "join_constraint", "compound_operator", "update_stmt",
"assignment_list", "assignment", "column_name_list", "update_stmt_limited",
"qualified_table_name", "vacuum_stmt", "filter_clause", "window_defn",
"over_clause", "frame_spec", "frame_clause", "simple_function_invocation",
"aggregate_function_invocation", "window_function_invocation", "common_table_stmt",
"order_by_stmt", "limit_stmt", "ordering_term", "asc_desc", "frame_left",
"frame_right", "frame_single", "window_function", "offset", "default_value",
"partition_by", "order_by_expr", "order_by_expr_asc_desc", "expr_asc_desc",
"initial_select", "recursive_select", "unary_operator", "error_message",
"module_argument", "column_alias", "keyword", "name", "function_name",
"schema_name", "table_name", "table_or_index_name", "column_name", "collation_name",
"foreign_table", "index_name", "trigger_name", "view_name", "module_name",
"pragma_name", "savepoint_name", "table_alias", "transaction_name",
"window_name", "alias", "filename", "base_window_name", "simple_func",
"aggregate_func", "table_function_name", "any_name",
}
staticData.predictionContextCache = antlr.NewPredictionContextCache()
staticData.serializedATN = []int32{
4, 1, 193, 2083, 2, 0, 7, 0, 2, 1, 7, 1, 2, 2, 7, 2, 2, 3, 7, 3, 2, 4,
7, 4, 2, 5, 7, 5, 2, 6, 7, 6, 2, 7, 7, 7, 2, 8, 7, 8, 2, 9, 7, 9, 2, 10,
7, 10, 2, 11, 7, 11, 2, 12, 7, 12, 2, 13, 7, 13, 2, 14, 7, 14, 2, 15, 7,
15, 2, 16, 7, 16, 2, 17, 7, 17, 2, 18, 7, 18, 2, 19, 7, 19, 2, 20, 7, 20,
2, 21, 7, 21, 2, 22, 7, 22, 2, 23, 7, 23, 2, 24, 7, 24, 2, 25, 7, 25, 2,
26, 7, 26, 2, 27, 7, 27, 2, 28, 7, 28, 2, 29, 7, 29, 2, 30, 7, 30, 2, 31,
7, 31, 2, 32, 7, 32, 2, 33, 7, 33, 2, 34, 7, 34, 2, 35, 7, 35, 2, 36, 7,
36, 2, 37, 7, 37, 2, 38, 7, 38, 2, 39, 7, 39, 2, 40, 7, 40, 2, 41, 7, 41,
2, 42, 7, 42, 2, 43, 7, 43, 2, 44, 7, 44, 2, 45, 7, 45, 2, 46, 7, 46, 2,
47, 7, 47, 2, 48, 7, 48, 2, 49, 7, 49, 2, 50, 7, 50, 2, 51, 7, 51, 2, 52,
7, 52, 2, 53, 7, 53, 2, 54, 7, 54, 2, 55, 7, 55, 2, 56, 7, 56, 2, 57, 7,
57, 2, 58, 7, 58, 2, 59, 7, 59, 2, 60, 7, 60, 2, 61, 7, 61, 2, 62, 7, 62,
2, 63, 7, 63, 2, 64, 7, 64, 2, 65, 7, 65, 2, 66, 7, 66, 2, 67, 7, 67, 2,
68, 7, 68, 2, 69, 7, 69, 2, 70, 7, 70, 2, 71, 7, 71, 2, 72, 7, 72, 2, 73,
7, 73, 2, 74, 7, 74, 2, 75, 7, 75, 2, 76, 7, 76, 2, 77, 7, 77, 2, 78, 7,
78, 2, 79, 7, 79, 2, 80, 7, 80, 2, 81, 7, 81, 2, 82, 7, 82, 2, 83, 7, 83,
2, 84, 7, 84, 2, 85, 7, 85, 2, 86, 7, 86, 2, 87, 7, 87, 2, 88, 7, 88, 2,
89, 7, 89, 2, 90, 7, 90, 2, 91, 7, 91, 2, 92, 7, 92, 2, 93, 7, 93, 2, 94,
7, 94, 2, 95, 7, 95, 2, 96, 7, 96, 2, 97, 7, 97, 2, 98, 7, 98, 2, 99, 7,
99, 2, 100, 7, 100, 2, 101, 7, 101, 2, 102, 7, 102, 2, 103, 7, 103, 2,
104, 7, 104, 2, 105, 7, 105, 2, 106, 7, 106, 2, 107, 7, 107, 2, 108, 7,
108, 2, 109, 7, 109, 2, 110, 7, 110, 2, 111, 7, 111, 2, 112, 7, 112, 1,
0, 5, 0, 228, 8, 0, 10, 0, 12, 0, 231, 9, 0, 1, 0, 1, 0, 1, 1, 5, 1, 236,
8, 1, 10, 1, 12, 1, 239, 9, 1, 1, 1, 1, 1, 4, 1, 243, 8, 1, 11, 1, 12,
1, 244, 1, 1, 5, 1, 248, 8, 1, 10, 1, 12, 1, 251, 9, 1, 1, 1, 5, 1, 254,
8, 1, 10, 1, 12, 1, 257, 9, 1, 1, 2, 1, 2, 1, 2, 3, 2, 262, 8, 2, 3, 2,
264, 8, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2,
1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2,
1, 2, 1, 2, 3, 2, 290, 8, 2, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 3, 3, 297, 8,
3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 3, 3, 304, 8, 3, 1, 3, 1, 3, 1, 3, 1,
3, 3, 3, 310, 8, 3, 1, 3, 1, 3, 3, 3, 314, 8, 3, 1, 3, 1, 3, 1, 3, 3, 3,
319, 8, 3, 1, 3, 3, 3, 322, 8, 3, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 3, 4, 329,
8, 4, 1, 4, 3, 4, 332, 8, 4, 1, 5, 1, 5, 3, 5, 336, 8, 5, 1, 5, 1, 5, 1,
5, 1, 5, 1, 6, 1, 6, 3, 6, 344, 8, 6, 1, 6, 1, 6, 3, 6, 348, 8, 6, 3, 6,
350, 8, 6, 1, 7, 1, 7, 3, 7, 354, 8, 7, 1, 8, 1, 8, 3, 8, 358, 8, 8, 1,
8, 1, 8, 3, 8, 362, 8, 8, 1, 8, 3, 8, 365, 8, 8, 1, 9, 1, 9, 1, 9, 1, 10,
1, 10, 3, 10, 372, 8, 10, 1, 10, 1, 10, 1, 11, 1, 11, 3, 11, 378, 8, 11,
1, 11, 1, 11, 1, 11, 1, 11, 3, 11, 384, 8, 11, 1, 11, 1, 11, 1, 11, 3,
11, 389, 8, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 1, 11, 5, 11,
398, 8, 11, 10, 11, 12, 11, 401, 9, 11, 1, 11, 1, 11, 1, 11, 3, 11, 406,
8, 11, 1, 12, 1, 12, 3, 12, 410, 8, 12, 1, 12, 1, 12, 3, 12, 414, 8, 12,
1, 12, 3, 12, 417, 8, 12, 1, 13, 1, 13, 3, 13, 421, 8, 13, 1, 13, 1, 13,
1, 13, 1, 13, 3, 13, 427, 8, 13, 1, 13, 1, 13, 1, 13, 3, 13, 432, 8, 13,
1, 13, 1, 13, 1, 13, 1, 13, 1, 13, 5, 13, 439, 8, 13, 10, 13, 12, 13, 442,
9, 13, 1, 13, 1, 13, 5, 13, 446, 8, 13, 10, 13, 12, 13, 449, 9, 13, 1,
13, 1, 13, 1, 13, 3, 13, 454, 8, 13, 1, 13, 1, 13, 3, 13, 458, 8, 13, 1,
14, 1, 14, 3, 14, 462, 8, 14, 1, 14, 5, 14, 465, 8, 14, 10, 14, 12, 14,
468, 9, 14, 1, 15, 4, 15, 471, 8, 15, 11, 15, 12, 15, 472, 1, 15, 1, 15,
1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 1, 15, 3, 15, 485, 8,
15, 1, 16, 1, 16, 3, 16, 489, 8, 16, 1, 16, 1, 16, 1, 16, 3, 16, 494, 8,
16, 1, 16, 3, 16, 497, 8, 16, 1, 16, 3, 16, 500, 8, 16, 1, 16, 1, 16, 1,
16, 3, 16, 505, 8, 16, 1, 16, 3, 16, 508, 8, 16, 1, 16, 1, 16, 1, 16, 1,
16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 3, 16, 522,
8, 16, 1, 16, 1, 16, 1, 16, 1, 16, 1, 16, 3, 16, 529, 8, 16, 1, 16, 1,
16, 1, 16, 1, 16, 1, 16, 3, 16, 536, 8, 16, 3, 16, 538, 8, 16, 1, 17, 3,
17, 541, 8, 17, 1, 17, 1, 17, 1, 18, 1, 18, 3, 18, 547, 8, 18, 1, 18, 1,
18, 1, 18, 3, 18, 552, 8, 18, 1, 18, 1, 18, 1, 18, 1, 18, 5, 18, 558, 8,
18, 10, 18, 12, 18, 561, 9, 18, 1, 18, 1, 18, 3, 18, 565, 8, 18, 1, 18,
1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 1, 18, 5,
18, 578, 8, 18, 10, 18, 12, 18, 581, 9, 18, 1, 18, 1, 18, 1, 18, 3, 18,
586, 8, 18, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 5, 19, 594, 8, 19,
10, 19, 12, 19, 597, 9, 19, 1, 19, 1, 19, 3, 19, 601, 8, 19, 1, 19, 1,
19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 1, 19, 3, 19, 611, 8, 19, 1, 19,
1, 19, 5, 19, 615, 8, 19, 10, 19, 12, 19, 618, 9, 19, 1, 19, 3, 19, 621,
8, 19, 1, 19, 1, 19, 1, 19, 3, 19, 626, 8, 19, 3, 19, 628, 8, 19, 1, 20,
1, 20, 1, 20, 1, 20, 1, 21, 1, 21, 3, 21, 636, 8, 21, 1, 21, 1, 21, 1,
21, 1, 21, 3, 21, 642, 8, 21, 1, 21, 1, 21, 1, 21, 3, 21, 647, 8, 21, 1,
21, 1, 21, 1, 21, 1, 21, 1, 21, 3, 21, 654, 8, 21, 1, 21, 1, 21, 1, 21,
1, 21, 1, 21, 1, 21, 1, 21, 5, 21, 663, 8, 21, 10, 21, 12, 21, 666, 9,
21, 3, 21, 668, 8, 21, 3, 21, 670, 8, 21, 1, 21, 1, 21, 1, 21, 1, 21, 1,
21, 3, 21, 677, 8, 21, 1, 21, 1, 21, 3, 21, 681, 8, 21, 1, 21, 1, 21, 1,
21, 1, 21, 1, 21, 3, 21, 688, 8, 21, 1, 21, 1, 21, 4, 21, 692, 8, 21, 11,
21, 12, 21, 693, 1, 21, 1, 21, 1, 22, 1, 22, 3, 22, 700, 8, 22, 1, 22,
1, 22, 1, 22, 1, 22, 3, 22, 706, 8, 22, 1, 22, 1, 22, 1, 22, 3, 22, 711,
8, 22, 1, 22, 1, 22, 1, 22, 1, 22, 1, 22, 5, 22, 718, 8, 22, 10, 22, 12,
22, 721, 9, 22, 1, 22, 1, 22, 3, 22, 725, 8, 22, 1, 22, 1, 22, 1, 22, 1,
23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 3, 23, 736, 8, 23, 1, 23, 1, 23,
1, 23, 3, 23, 741, 8, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1, 23, 1,
23, 5, 23, 750, 8, 23, 10, 23, 12, 23, 753, 9, 23, 1, 23, 1, 23, 3, 23,
757, 8, 23, 1, 24, 1, 24, 3, 24, 761, 8, 24, 1, 24, 1, 24, 1, 24, 1, 24,
1, 24, 1, 24, 1, 24, 1, 24, 1, 24, 1, 24, 1, 24, 1, 24, 5, 24, 775, 8,
24, 10, 24, 12, 24, 778, 9, 24, 1, 25, 1, 25, 1, 25, 1, 25, 1, 25, 5, 25,
785, 8, 25, 10, 25, 12, 25, 788, 9, 25, 1, 25, 1, 25, 3, 25, 792, 8, 25,
1, 26, 1, 26, 1, 26, 1, 26, 1, 26, 1, 26, 3, 26, 800, 8, 26, 1, 26, 1,
26, 1, 26, 1, 27, 1, 27, 1, 27, 1, 27, 1, 27, 5, 27, 810, 8, 27, 10, 27,
12, 27, 813, 9, 27, 1, 27, 1, 27, 3, 27, 817, 8, 27, 1, 27, 1, 27, 1, 27,
1, 27, 1, 27, 1, 28, 3, 28, 825, 8, 28, 1, 28, 1, 28, 1, 28, 1, 28, 1,
28, 3, 28, 832, 8, 28, 1, 28, 3, 28, 835, 8, 28, 1, 29, 3, 29, 838, 8,
29, 1, 29, 1, 29, 1, 29, 1, 29, 1, 29, 3, 29, 845, 8, 29, 1, 29, 3, 29,
848, 8, 29, 1, 29, 3, 29, 851, 8, 29, 1, 29, 3, 29, 854, 8, 29, 1, 30,
1, 30, 3, 30, 858, 8, 30, 1, 30, 1, 30, 1, 31, 1, 31, 1, 31, 1, 31, 3,
31, 866, 8, 31, 1, 31, 1, 31, 1, 31, 3, 31, 871, 8, 31, 1, 31, 1, 31, 1,
32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 3, 32, 881, 8, 32, 1, 32, 1, 32,
1, 32, 3, 32, 886, 8, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1,
32, 3, 32, 895, 8, 32, 1, 32, 1, 32, 1, 32, 5, 32, 900, 8, 32, 10, 32,
12, 32, 903, 9, 32, 1, 32, 3, 32, 906, 8, 32, 1, 32, 1, 32, 3, 32, 910,
8, 32, 1, 32, 3, 32, 913, 8, 32, 1, 32, 1, 32, 1, 32, 1, 32, 5, 32, 919,
8, 32, 10, 32, 12, 32, 922, 9, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1,
32, 1, 32, 1, 32, 1, 32, 1, 32, 3, 32, 934, 8, 32, 1, 32, 3, 32, 937, 8,
32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 3, 32, 945, 8, 32, 1, 32,
1, 32, 1, 32, 1, 32, 1, 32, 4, 32, 952, 8, 32, 11, 32, 12, 32, 953, 1,
32, 1, 32, 3, 32, 958, 8, 32, 1, 32, 1, 32, 1, 32, 3, 32, 963, 8, 32, 1,
32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32,
1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1,
32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 3, 32, 993, 8, 32, 1, 32,
1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 3, 32, 1005,
8, 32, 1, 32, 1, 32, 1, 32, 3, 32, 1010, 8, 32, 1, 32, 1, 32, 1, 32, 1,
32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1, 32, 3, 32, 1022, 8, 32, 1, 32,
1, 32, 1, 32, 1, 32, 3, 32, 1028, 8, 32, 1, 32, 1, 32, 1, 32, 1, 32, 1,
32, 3, 32, 1035, 8, 32, 1, 32, 1, 32, 3, 32, 1039, 8, 32, 1, 32, 1, 32,
1, 32, 1, 32, 1, 32, 1, 32, 5, 32, 1047, 8, 32, 10, 32, 12, 32, 1050, 9,
32, 3, 32, 1052, 8, 32, 1, 32, 1, 32, 1, 32, 1, 32, 3, 32, 1058, 8, 32,
1, 32, 1, 32, 1, 32, 1, 32, 3, 32, 1064, 8, 32, 1, 32, 1, 32, 1, 32, 1,
32, 1, 32, 5, 32, 1071, 8, 32, 10, 32, 12, 32, 1074, 9, 32, 3, 32, 1076,
8, 32, 1, 32, 1, 32, 3, 32, 1080, 8, 32, 5, 32, 1082, 8, 32, 10, 32, 12,
32, 1085, 9, 32, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 1, 33, 3, 33, 1093,
8, 33, 1, 33, 1, 33, 1, 34, 1, 34, 1, 35, 3, 35, 1100, 8, 35, 1, 35, 1,
35, 1, 35, 1, 35, 1, 35, 3, 35, 1107, 8, 35, 1, 35, 1, 35, 1, 35, 1, 35,
3, 35, 1113, 8, 35, 1, 35, 1, 35, 1, 35, 3, 35, 1118, 8, 35, 1, 35, 1,
35, 1, 35, 1, 35, 5, 35, 1124, 8, 35, 10, 35, 12, 35, 1127, 9, 35, 1, 35,
1, 35, 3, 35, 1131, 8, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35, 5, 35, 1138,
8, 35, 10, 35, 12, 35, 1141, 9, 35, 1, 35, 1, 35, 1, 35, 1, 35, 1, 35,
1, 35, 5, 35, 1149, 8, 35, 10, 35, 12, 35, 1152, 9, 35, 1, 35, 1, 35, 5,
35, 1156, 8, 35, 10, 35, 12, 35, 1159, 9, 35, 1, 35, 3, 35, 1162, 8, 35,
1, 35, 3, 35, 1165, 8, 35, 1, 35, 1, 35, 3, 35, 1169, 8, 35, 1, 35, 3,
35, 1172, 8, 35, 1, 36, 1, 36, 1, 36, 1, 36, 5, 36, 1178, 8, 36, 10, 36,
12, 36, 1181, 9, 36, 1, 37, 1, 37, 1, 37, 1, 37, 1, 37, 1, 37, 5, 37, 1189,
8, 37, 10, 37, 12, 37, 1192, 9, 37, 1, 37, 1, 37, 1, 37, 3, 37, 1197, 8,
37, 3, 37, 1199, 8, 37, 1, 37, 1, 37, 1, 37, 1, 37, 1, 37, 1, 37, 3, 37,
1207, 8, 37, 1, 37, 1, 37, 1, 37, 1, 37, 1, 37, 3, 37, 1214, 8, 37, 1,
37, 1, 37, 1, 37, 5, 37, 1219, 8, 37, 10, 37, 12, 37, 1222, 9, 37, 1, 37,
1, 37, 3, 37, 1226, 8, 37, 3, 37, 1228, 8, 37, 1, 38, 1, 38, 1, 38, 1,
38, 3, 38, 1234, 8, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38, 1, 38,
3, 38, 1243, 8, 38, 1, 39, 1, 39, 1, 39, 3, 39, 1248, 8, 39, 1, 40, 1,
40, 1, 40, 1, 40, 1, 40, 3, 40, 1255, 8, 40, 1, 40, 1, 40, 3, 40, 1259,
8, 40, 3, 40, 1261, 8, 40, 1, 41, 3, 41, 1264, 8, 41, 1, 41, 1, 41, 1,
41, 1, 41, 5, 41, 1270, 8, 41, 10, 41, 12, 41, 1273, 9, 41, 1, 41, 3, 41,
1276, 8, 41, 1, 41, 3, 41, 1279, 8, 41, 1, 42, 1, 42, 1, 42, 1, 42, 3,
42, 1285, 8, 42, 5, 42, 1287, 8, 42, 10, 42, 12, 42, 1290, 9, 42, 1, 43,
1, 43, 3, 43, 1294, 8, 43, 1, 43, 1, 43, 1, 43, 5, 43, 1299, 8, 43, 10,
43, 12, 43, 1302, 9, 43, 1, 43, 1, 43, 1, 43, 1, 43, 5, 43, 1308, 8, 43,
10, 43, 12, 43, 1311, 9, 43, 1, 43, 3, 43, 1314, 8, 43, 3, 43, 1316, 8,
43, 1, 43, 1, 43, 3, 43, 1320, 8, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43,
5, 43, 1327, 8, 43, 10, 43, 12, 43, 1330, 9, 43, 1, 43, 1, 43, 3, 43, 1334,
8, 43, 3, 43, 1336, 8, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1,
43, 1, 43, 1, 43, 5, 43, 1347, 8, 43, 10, 43, 12, 43, 1350, 9, 43, 3, 43,
1352, 8, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 5, 43, 1359, 8, 43, 10,
43, 12, 43, 1362, 9, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 1, 43, 5, 43,
1370, 8, 43, 10, 43, 12, 43, 1373, 9, 43, 1, 43, 1, 43, 5, 43, 1377, 8,
43, 10, 43, 12, 43, 1380, 9, 43, 3, 43, 1382, 8, 43, 1, 44, 1, 44, 1, 45,
3, 45, 1387, 8, 45, 1, 45, 1, 45, 3, 45, 1391, 8, 45, 1, 45, 3, 45, 1394,
8, 45, 1, 46, 3, 46, 1397, 8, 46, 1, 46, 1, 46, 1, 46, 3, 46, 1402, 8,
46, 1, 46, 1, 46, 3, 46, 1406, 8, 46, 1, 46, 4, 46, 1409, 8, 46, 11, 46,
12, 46, 1410, 1, 46, 3, 46, 1414, 8, 46, 1, 46, 3, 46, 1417, 8, 46, 1,
47, 1, 47, 1, 47, 3, 47, 1422, 8, 47, 1, 47, 1, 47, 3, 47, 1426, 8, 47,
1, 47, 3, 47, 1429, 8, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 3, 47, 1436,
8, 47, 1, 47, 1, 47, 1, 47, 3, 47, 1441, 8, 47, 1, 47, 1, 47, 1, 47, 1,
47, 1, 47, 5, 47, 1448, 8, 47, 10, 47, 12, 47, 1451, 9, 47, 1, 47, 1, 47,
3, 47, 1455, 8, 47, 1, 47, 3, 47, 1458, 8, 47, 1, 47, 1, 47, 1, 47, 1,
47, 5, 47, 1464, 8, 47, 10, 47, 12, 47, 1467, 9, 47, 1, 47, 3, 47, 1470,
8, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 1, 47, 3, 47, 1478, 8, 47, 1,
47, 3, 47, 1481, 8, 47, 3, 47, 1483, 8, 47, 1, 48, 1, 48, 1, 48, 1, 48,
1, 48, 1, 48, 1, 48, 3, 48, 1492, 8, 48, 1, 48, 3, 48, 1495, 8, 48, 3,
48, 1497, 8, 48, 1, 49, 1, 49, 3, 49, 1501, 8, 49, 1, 49, 1, 49, 3, 49,
1505, 8, 49, 1, 49, 1, 49, 3, 49, 1509, 8, 49, 1, 49, 3, 49, 1512, 8, 49,
1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 1, 50, 5, 50, 1521, 8, 50, 10,
50, 12, 50, 1524, 9, 50, 1, 50, 1, 50, 3, 50, 1528, 8, 50, 1, 51, 1, 51,
3, 51, 1532, 8, 51, 1, 51, 1, 51, 3, 51, 1536, 8, 51, 1, 52, 3, 52, 1539,
8, 52, 1, 52, 1, 52, 1, 52, 3, 52, 1544, 8, 52, 1, 52, 1, 52, 1, 52, 1,
52, 1, 52, 1, 52, 1, 52, 5, 52, 1553, 8, 52, 10, 52, 12, 52, 1556, 9, 52,
1, 52, 3, 52, 1559, 8, 52, 3, 52, 1561, 8, 52, 1, 52, 1, 52, 3, 52, 1565,
8, 52, 1, 52, 3, 52, 1568, 8, 52, 1, 53, 1, 53, 1, 53, 5, 53, 1573, 8,
53, 10, 53, 12, 53, 1576, 9, 53, 1, 54, 1, 54, 3, 54, 1580, 8, 54, 1, 54,
1, 54, 1, 54, 1, 55, 1, 55, 1, 55, 1, 55, 5, 55, 1589, 8, 55, 10, 55, 12,
55, 1592, 9, 55, 1, 55, 1, 55, 1, 56, 3, 56, 1597, 8, 56, 1, 56, 1, 56,
1, 56, 3, 56, 1602, 8, 56, 1, 56, 1, 56, 1, 56, 1, 56, 3, 56, 1608, 8,
56, 1, 56, 1, 56, 1, 56, 1, 56, 1, 56, 3, 56, 1615, 8, 56, 1, 56, 1, 56,
1, 56, 5, 56, 1620, 8, 56, 10, 56, 12, 56, 1623, 9, 56, 1, 56, 1, 56, 3,
56, 1627, 8, 56, 1, 56, 3, 56, 1630, 8, 56, 1, 56, 3, 56, 1633, 8, 56,
1, 56, 3, 56, 1636, 8, 56, 1, 57, 1, 57, 1, 57, 3, 57, 1641, 8, 57, 1,
57, 1, 57, 1, 57, 3, 57, 1646, 8, 57, 1, 57, 1, 57, 1, 57, 1, 57, 1, 57,
3, 57, 1653, 8, 57, 1, 58, 1, 58, 3, 58, 1657, 8, 58, 1, 58, 1, 58, 3,
58, 1661, 8, 58, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 59, 1, 60, 1, 60,
3, 60, 1671, 8, 60, 1, 60, 1, 60, 1, 60, 1, 60, 1, 60, 5, 60, 1678, 8,
60, 10, 60, 12, 60, 1681, 9, 60, 3, 60, 1683, 8, 60, 1, 60, 1, 60, 1, 60,
1, 60, 1, 60, 5, 60, 1690, 8, 60, 10, 60, 12, 60, 1693, 9, 60, 1, 60, 3,
60, 1696, 8, 60, 1, 60, 1, 60, 1, 61, 1, 61, 1, 61, 1, 61, 3, 61, 1704,
8, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61, 5, 61, 1711, 8, 61, 10, 61, 12,
61, 1714, 9, 61, 3, 61, 1716, 8, 61, 1, 61, 1, 61, 1, 61, 1, 61, 1, 61,
5, 61, 1723, 8, 61, 10, 61, 12, 61, 1726, 9, 61, 3, 61, 1728, 8, 61, 1,
61, 3, 61, 1731, 8, 61, 1, 61, 3, 61, 1734, 8, 61, 1, 62, 1, 62, 1, 62,
1, 62, 1, 62, 1, 62, 1, 62, 1, 62, 3, 62, 1744, 8, 62, 1, 63, 1, 63, 1,
63, 1, 63, 1, 63, 1, 63, 1, 63, 3, 63, 1753, 8, 63, 1, 64, 1, 64, 1, 64,
1, 64, 1, 64, 5, 64, 1760, 8, 64, 10, 64, 12, 64, 1763, 9, 64, 1, 64, 3,
64, 1766, 8, 64, 1, 64, 1, 64, 1, 65, 1, 65, 1, 65, 3, 65, 1773, 8, 65,
1, 65, 1, 65, 1, 65, 5, 65, 1778, 8, 65, 10, 65, 12, 65, 1781, 9, 65, 1,
65, 3, 65, 1784, 8, 65, 1, 65, 1, 65, 3, 65, 1788, 8, 65, 1, 66, 1, 66,
1, 66, 1, 66, 1, 66, 5, 66, 1795, 8, 66, 10, 66, 12, 66, 1798, 9, 66, 1,
66, 3, 66, 1801, 8, 66, 1, 66, 1, 66, 3, 66, 1805, 8, 66, 1, 66, 1, 66,
1, 66, 3, 66, 1810, 8, 66, 1, 67, 1, 67, 3, 67, 1814, 8, 67, 1, 67, 1,
67, 1, 67, 5, 67, 1819, 8, 67, 10, 67, 12, 67, 1822, 9, 67, 1, 68, 1, 68,
1, 68, 1, 68, 1, 68, 5, 68, 1829, 8, 68, 10, 68, 12, 68, 1832, 9, 68, 1,
69, 1, 69, 1, 69, 1, 69, 3, 69, 1838, 8, 69, 1, 70, 1, 70, 1, 70, 3, 70,
1843, 8, 70, 1, 70, 3, 70, 1846, 8, 70, 1, 70, 1, 70, 3, 70, 1850, 8, 70,
1, 71, 1, 71, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1, 72, 1,
72, 1, 72, 3, 72, 1864, 8, 72, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73, 1, 73,
1, 73, 1, 73, 1, 73, 1, 73, 3, 73, 1876, 8, 73, 1, 74, 1, 74, 1, 74, 1,
74, 1, 74, 1, 74, 1, 74, 3, 74, 1885, 8, 74, 1, 75, 1, 75, 1, 75, 1, 75,
1, 75, 1, 75, 1, 75, 3, 75, 1894, 8, 75, 1, 75, 1, 75, 3, 75, 1898, 8,
75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 3, 75, 1908,
8, 75, 1, 75, 3, 75, 1911, 8, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1,
75, 1, 75, 3, 75, 1920, 8, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75,
1, 75, 3, 75, 1929, 8, 75, 1, 75, 3, 75, 1932, 8, 75, 1, 75, 1, 75, 1,
75, 1, 75, 3, 75, 1938, 8, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75,
1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 3, 75, 1952, 8, 75, 1, 75, 1,
75, 3, 75, 1956, 8, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75, 1, 75,
1, 75, 1, 75, 3, 75, 1967, 8, 75, 1, 75, 1, 75, 1, 75, 3, 75, 1972, 8,
75, 1, 76, 1, 76, 1, 76, 1, 77, 1, 77, 1, 77, 1, 78, 1, 78, 1, 78, 4, 78,
1983, 8, 78, 11, 78, 12, 78, 1984, 1, 79, 1, 79, 1, 79, 4, 79, 1990, 8,
79, 11, 79, 12, 79, 1991, 1, 80, 1, 80, 1, 80, 1, 80, 1, 81, 1, 81, 3,
81, 2000, 8, 81, 1, 81, 1, 81, 1, 81, 3, 81, 2005, 8, 81, 5, 81, 2007,
8, 81, 10, 81, 12, 81, 2010, 9, 81, 1, 82, 1, 82, 1, 83, 1, 83, 1, 84,
1, 84, 1, 85, 1, 85, 1, 86, 1, 86, 3, 86, 2022, 8, 86, 1, 87, 1, 87, 1,
88, 1, 88, 1, 89, 1, 89, 1, 90, 1, 90, 1, 91, 1, 91, 1, 92, 1, 92, 1, 93,
1, 93, 1, 94, 1, 94, 1, 95, 1, 95, 1, 96, 1, 96, 1, 97, 1, 97, 1, 98, 1,
98, 1, 99, 1, 99, 1, 100, 1, 100, 1, 101, 1, 101, 1, 102, 1, 102, 1, 103,
1, 103, 1, 104, 1, 104, 1, 105, 1, 105, 1, 106, 1, 106, 1, 107, 1, 107,
1, 108, 1, 108, 1, 109, 1, 109, 1, 110, 1, 110, 1, 111, 1, 111, 1, 112,
1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 1, 112, 3, 112, 2081, 8, 112, 1,
112, 2, 440, 472, 1, 64, 113, 0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22,
24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 56, 58,
60, 62, 64, 66, 68, 70, 72, 74, 76, 78, 80, 82, 84, 86, 88, 90, 92, 94,
96, 98, 100, 102, 104, 106, 108, 110, 112, 114, 116, 118, 120, 122, 124,
126, 128, 130, 132, 134, 136, 138, 140, 142, 144, 146, 148, 150, 152, 154,
156, 158, 160, 162, 164, 166, 168, 170, 172, 174, 176, 178, 180, 182, 184,
186, 188, 190, 192, 194, 196, 198, 200, 202, 204, 206, 208, 210, 212, 214,
216, 218, 220, 222, 224, 0, 28, 3, 0, 58, 58, 69, 69, 82, 82, 2, 0, 47,
47, 66, 66, 1, 0, 133, 134, 2, 0, 146, 146, 171, 171, 1, 0, 8, 9, 2, 0,
59, 59, 141, 141, 2, 0, 56, 56, 104, 104, 2, 0, 58, 58, 82, 82, 5, 0, 25,
25, 72, 72, 81, 81, 122, 122, 126, 126, 4, 0, 84, 84, 132, 132, 138, 138,
145, 145, 2, 0, 7, 7, 12, 13, 1, 0, 14, 17, 1, 0, 18, 21, 4, 0, 77, 77,
97, 97, 99, 99, 118, 118, 3, 0, 25, 25, 72, 72, 126, 126, 5, 0, 52, 54,
104, 104, 172, 173, 186, 186, 188, 189, 2, 0, 29, 29, 62, 62, 3, 0, 128,
128, 154, 154, 179, 179, 2, 0, 5, 5, 106, 106, 1, 0, 176, 177, 2, 0, 34,
34, 60, 60, 2, 0, 151, 151, 162, 162, 2, 0, 159, 159, 166, 166, 2, 0, 160,
160, 167, 168, 2, 0, 161, 161, 163, 163, 2, 0, 8, 10, 102, 102, 2, 0, 185,
185, 188, 188, 2, 0, 25, 123, 125, 180, 2367, 0, 229, 1, 0, 0, 0, 2, 237,
1, 0, 0, 0, 4, 263, 1, 0, 0, 0, 6, 291, 1, 0, 0, 0, 8, 323, 1, 0, 0, 0,
10, 333, 1, 0, 0, 0, 12, 341, 1, 0, 0, 0, 14, 351, 1, 0, 0, 0, 16, 355,
1, 0, 0, 0, 18, 366, 1, 0, 0, 0, 20, 369, 1, 0, 0, 0, 22, 375, 1, 0, 0,
0, 24, 409, 1, 0, 0, 0, 26, 418, 1, 0, 0, 0, 28, 459, 1, 0, 0, 0, 30, 470,
1, 0, 0, 0, 32, 488, 1, 0, 0, 0, 34, 540, 1, 0, 0, 0, 36, 546, 1, 0, 0,
0, 38, 587, 1, 0, 0, 0, 40, 629, 1, 0, 0, 0, 42, 633, 1, 0, 0, 0, 44, 697,
1, 0, 0, 0, 46, 729, 1, 0, 0, 0, 48, 758, 1, 0, 0, 0, 50, 779, 1, 0, 0,
0, 52, 793, 1, 0, 0, 0, 54, 804, 1, 0, 0, 0, 56, 824, 1, 0, 0, 0, 58, 837,
1, 0, 0, 0, 60, 855, 1, 0, 0, 0, 62, 861, 1, 0, 0, 0, 64, 962, 1, 0, 0,
0, 66, 1086, 1, 0, 0, 0, 68, 1096, 1, 0, 0, 0, 70, 1099, 1, 0, 0, 0, 72,
1173, 1, 0, 0, 0, 74, 1182, 1, 0, 0, 0, 76, 1229, 1, 0, 0, 0, 78, 1247,
1, 0, 0, 0, 80, 1249, 1, 0, 0, 0, 82, 1263, 1, 0, 0, 0, 84, 1280, 1, 0,
0, 0, 86, 1381, 1, 0, 0, 0, 88, 1383, 1, 0, 0, 0, 90, 1386, 1, 0, 0, 0,
92, 1396, 1, 0, 0, 0, 94, 1482, 1, 0, 0, 0, 96, 1496, 1, 0, 0, 0, 98, 1511,
1, 0, 0, 0, 100, 1527, 1, 0, 0, 0, 102, 1535, 1, 0, 0, 0, 104, 1538, 1,
0, 0, 0, 106, 1569, 1, 0, 0, 0, 108, 1579, 1, 0, 0, 0, 110, 1584, 1, 0,
0, 0, 112, 1596, 1, 0, 0, 0, 114, 1640, 1, 0, 0, 0, 116, 1654, 1, 0, 0,
0, 118, 1662, 1, 0, 0, 0, 120, 1668, 1, 0, 0, 0, 122, 1699, 1, 0, 0, 0,
124, 1735, 1, 0, 0, 0, 126, 1745, 1, 0, 0, 0, 128, 1754, 1, 0, 0, 0, 130,
1769, 1, 0, 0, 0, 132, 1789, 1, 0, 0, 0, 134, 1811, 1, 0, 0, 0, 136, 1823,
1, 0, 0, 0, 138, 1833, 1, 0, 0, 0, 140, 1839, 1, 0, 0, 0, 142, 1851, 1,
0, 0, 0, 144, 1863, 1, 0, 0, 0, 146, 1875, 1, 0, 0, 0, 148, 1884, 1, 0,
0, 0, 150, 1971, 1, 0, 0, 0, 152, 1973, 1, 0, 0, 0, 154, 1976, 1, 0, 0,
0, 156, 1979, 1, 0, 0, 0, 158, 1986, 1, 0, 0, 0, 160, 1993, 1, 0, 0, 0,
162, 1997, 1, 0, 0, 0, 164, 2011, 1, 0, 0, 0, 166, 2013, 1, 0, 0, 0, 168,
2015, 1, 0, 0, 0, 170, 2017, 1, 0, 0, 0, 172, 2021, 1, 0, 0, 0, 174, 2023,
1, 0, 0, 0, 176, 2025, 1, 0, 0, 0, 178, 2027, 1, 0, 0, 0, 180, 2029, 1,
0, 0, 0, 182, 2031, 1, 0, 0, 0, 184, 2033, 1, 0, 0, 0, 186, 2035, 1, 0,
0, 0, 188, 2037, 1, 0, 0, 0, 190, 2039, 1, 0, 0, 0, 192, 2041, 1, 0, 0,
0, 194, 2043, 1, 0, 0, 0, 196, 2045, 1, 0, 0, 0, 198, 2047, 1, 0, 0, 0,
200, 2049, 1, 0, 0, 0, 202, 2051, 1, 0, 0, 0, 204, 2053, 1, 0, 0, 0, 206,
2055, 1, 0, 0, 0, 208, 2057, 1, 0, 0, 0, 210, 2059, 1, 0, 0, 0, 212, 2061,
1, 0, 0, 0, 214, 2063, 1, 0, 0, 0, 216, 2065, 1, 0, 0, 0, 218, 2067, 1,
0, 0, 0, 220, 2069, 1, 0, 0, 0, 222, 2071, 1, 0, 0, 0, 224, 2080, 1, 0,
0, 0, 226, 228, 3, 2, 1, 0, 227, 226, 1, 0, 0, 0, 228, 231, 1, 0, 0, 0,
229, 227, 1, 0, 0, 0, 229, 230, 1, 0, 0, 0, 230, 232, 1, 0, 0, 0, 231,
229, 1, 0, 0, 0, 232, 233, 5, 0, 0, 1, 233, 1, 1, 0, 0, 0, 234, 236, 5,
1, 0, 0, 235, 234, 1, 0, 0, 0, 236, 239, 1, 0, 0, 0, 237, 235, 1, 0, 0,
0, 237, 238, 1, 0, 0, 0, 238, 240, 1, 0, 0, 0, 239, 237, 1, 0, 0, 0, 240,
249, 3, 4, 2, 0, 241, 243, 5, 1, 0, 0, 242, 241, 1, 0, 0, 0, 243, 244,
1, 0, 0, 0, 244, 242, 1, 0, 0, 0, 244, 245, 1, 0, 0, 0, 245, 246, 1, 0,
0, 0, 246, 248, 3, 4, 2, 0, 247, 242, 1, 0, 0, 0, 248, 251, 1, 0, 0, 0,
249, 247, 1, 0, 0, 0, 249, 250, 1, 0, 0, 0, 250, 255, 1, 0, 0, 0, 251,
249, 1, 0, 0, 0, 252, 254, 5, 1, 0, 0, 253, 252, 1, 0, 0, 0, 254, 257,
1, 0, 0, 0, 255, 253, 1, 0, 0, 0, 255, 256, 1, 0, 0, 0, 256, 3, 1, 0, 0,
0, 257, 255, 1, 0, 0, 0, 258, 261, 5, 71, 0, 0, 259, 260, 5, 114, 0, 0,
260, 262, 5, 111, 0, 0, 261, 259, 1, 0, 0, 0, 261, 262, 1, 0, 0, 0, 262,
264, 1, 0, 0, 0, 263, 258, 1, 0, 0, 0, 263, 264, 1, 0, 0, 0, 264, 289,
1, 0, 0, 0, 265, 290, 3, 6, 3, 0, 266, 290, 3, 8, 4, 0, 267, 290, 3, 10,
5, 0, 268, 290, 3, 12, 6, 0, 269, 290, 3, 14, 7, 0, 270, 290, 3, 22, 11,
0, 271, 290, 3, 26, 13, 0, 272, 290, 3, 42, 21, 0, 273, 290, 3, 44, 22,
0, 274, 290, 3, 46, 23, 0, 275, 290, 3, 56, 28, 0, 276, 290, 3, 58, 29,
0, 277, 290, 3, 60, 30, 0, 278, 290, 3, 62, 31, 0, 279, 290, 3, 70, 35,
0, 280, 290, 3, 76, 38, 0, 281, 290, 3, 80, 40, 0, 282, 290, 3, 20, 10,
0, 283, 290, 3, 16, 8, 0, 284, 290, 3, 18, 9, 0, 285, 290, 3, 82, 41, 0,
286, 290, 3, 104, 52, 0, 287, 290, 3, 112, 56, 0, 288, 290, 3, 116, 58,
0, 289, 265, 1, 0, 0, 0, 289, 266, 1, 0, 0, 0, 289, 267, 1, 0, 0, 0, 289,
268, 1, 0, 0, 0, 289, 269, 1, 0, 0, 0, 289, 270, 1, 0, 0, 0, 289, 271,
1, 0, 0, 0, 289, 272, 1, 0, 0, 0, 289, 273, 1, 0, 0, 0, 289, 274, 1, 0,
0, 0, 289, 275, 1, 0, 0, 0, 289, 276, 1, 0, 0, 0, 289, 277, 1, 0, 0, 0,
289, 278, 1, 0, 0, 0, 289, 279, 1, 0, 0, 0, 289, 280, 1, 0, 0, 0, 289,
281, 1, 0, 0, 0, 289, 282, 1, 0, 0, 0, 289, 283, 1, 0, 0, 0, 289, 284,
1, 0, 0, 0, 289, 285, 1, 0, 0, 0, 289, 286, 1, 0, 0, 0, 289, 287, 1, 0,
0, 0, 289, 288, 1, 0, 0, 0, 290, 5, 1, 0, 0, 0, 291, 292, 5, 30, 0, 0,
292, 296, 5, 132, 0, 0, 293, 294, 3, 182, 91, 0, 294, 295, 5, 2, 0, 0,
295, 297, 1, 0, 0, 0, 296, 293, 1, 0, 0, 0, 296, 297, 1, 0, 0, 0, 297,
298, 1, 0, 0, 0, 298, 321, 3, 184, 92, 0, 299, 309, 5, 121, 0, 0, 300,
301, 5, 136, 0, 0, 301, 310, 3, 184, 92, 0, 302, 304, 5, 46, 0, 0, 303,
302, 1, 0, 0, 0, 303, 304, 1, 0, 0, 0, 304, 305, 1, 0, 0, 0, 305, 306,
3, 188, 94, 0, 306, 307, 5, 136, 0, 0, 307, 308, 3, 188, 94, 0, 308, 310,
1, 0, 0, 0, 309, 300, 1, 0, 0, 0, 309, 303, 1, 0, 0, 0, 310, 322, 1, 0,
0, 0, 311, 313, 5, 27, 0, 0, 312, 314, 5, 46, 0, 0, 313, 312, 1, 0, 0,
0, 313, 314, 1, 0, 0, 0, 314, 315, 1, 0, 0, 0, 315, 322, 3, 28, 14, 0,
316, 318, 5, 63, 0, 0, 317, 319, 5, 46, 0, 0, 318, 317, 1, 0, 0, 0, 318,
319, 1, 0, 0, 0, 319, 320, 1, 0, 0, 0, 320, 322, 3, 188, 94, 0, 321, 299,
1, 0, 0, 0, 321, 311, 1, 0, 0, 0, 321, 316, 1, 0, 0, 0, 322, 7, 1, 0, 0,
0, 323, 331, 5, 31, 0, 0, 324, 332, 3, 182, 91, 0, 325, 326, 3, 182, 91,
0, 326, 327, 5, 2, 0, 0, 327, 329, 1, 0, 0, 0, 328, 325, 1, 0, 0, 0, 328,
329, 1, 0, 0, 0, 329, 330, 1, 0, 0, 0, 330, 332, 3, 186, 93, 0, 331, 324,
1, 0, 0, 0, 331, 328, 1, 0, 0, 0, 331, 332, 1, 0, 0, 0, 332, 9, 1, 0, 0,
0, 333, 335, 5, 35, 0, 0, 334, 336, 5, 55, 0, 0, 335, 334, 1, 0, 0, 0,
335, 336, 1, 0, 0, 0, 336, 337, 1, 0, 0, 0, 337, 338, 3, 64, 32, 0, 338,
339, 5, 33, 0, 0, 339, 340, 3, 182, 91, 0, 340, 11, 1, 0, 0, 0, 341, 343,
5, 38, 0, 0, 342, 344, 7, 0, 0, 0, 343, 342, 1, 0, 0, 0, 343, 344, 1, 0,
0, 0, 344, 349, 1, 0, 0, 0, 345, 347, 5, 137, 0, 0, 346, 348, 3, 208, 104,
0, 347, 346, 1, 0, 0, 0, 347, 348, 1, 0, 0, 0, 348, 350, 1, 0, 0, 0, 349,
345, 1, 0, 0, 0, 349, 350, 1, 0, 0, 0, 350, 13, 1, 0, 0, 0, 351, 353, 7,
1, 0, 0, 352, 354, 5, 137, 0, 0, 353, 352, 1, 0, 0, 0, 353, 354, 1, 0,
0, 0, 354, 15, 1, 0, 0, 0, 355, 357, 5, 126, 0, 0, 356, 358, 5, 137, 0,
0, 357, 356, 1, 0, 0, 0, 357, 358, 1, 0, 0, 0, 358, 364, 1, 0, 0, 0, 359,
361, 5, 136, 0, 0, 360, 362, 5, 129, 0, 0, 361, 360, 1, 0, 0, 0, 361, 362,
1, 0, 0, 0, 362, 363, 1, 0, 0, 0, 363, 365, 3, 204, 102, 0, 364, 359, 1,
0, 0, 0, 364, 365, 1, 0, 0, 0, 365, 17, 1, 0, 0, 0, 366, 367, 5, 129, 0,
0, 367, 368, 3, 204, 102, 0, 368, 19, 1, 0, 0, 0, 369, 371, 5, 120, 0,
0, 370, 372, 5, 129, 0, 0, 371, 370, 1, 0, 0, 0, 371, 372, 1, 0, 0, 0,
372, 373, 1, 0, 0, 0, 373, 374, 3, 204, 102, 0, 374, 21, 1, 0, 0, 0, 375,
377, 5, 50, 0, 0, 376, 378, 5, 140, 0, 0, 377, 376, 1, 0, 0, 0, 377, 378,
1, 0, 0, 0, 378, 379, 1, 0, 0, 0, 379, 383, 5, 84, 0, 0, 380, 381, 5, 80,
0, 0, 381, 382, 5, 102, 0, 0, 382, 384, 5, 70, 0, 0, 383, 380, 1, 0, 0,
0, 383, 384, 1, 0, 0, 0, 384, 388, 1, 0, 0, 0, 385, 386, 3, 182, 91, 0,
386, 387, 5, 2, 0, 0, 387, 389, 1, 0, 0, 0, 388, 385, 1, 0, 0, 0, 388,
389, 1, 0, 0, 0, 389, 390, 1, 0, 0, 0, 390, 391, 3, 194, 97, 0, 391, 392,
5, 107, 0, 0, 392, 393, 3, 184, 92, 0, 393, 394, 5, 3, 0, 0, 394, 399,
3, 24, 12, 0, 395, 396, 5, 5, 0, 0, 396, 398, 3, 24, 12, 0, 397, 395, 1,
0, 0, 0, 398, 401, 1, 0, 0, 0, 399, 397, 1, 0, 0, 0, 399, 400, 1, 0, 0,
0, 400, 402, 1, 0, 0, 0, 401, 399, 1, 0, 0, 0, 402, 405, 5, 4, 0, 0, 403,
404, 5, 148, 0, 0, 404, 406, 3, 64, 32, 0, 405, 403, 1, 0, 0, 0, 405, 406,
1, 0, 0, 0, 406, 23, 1, 0, 0, 0, 407, 410, 3, 188, 94, 0, 408, 410, 3,
64, 32, 0, 409, 407, 1, 0, 0, 0, 409, 408, 1, 0, 0, 0, 410, 413, 1, 0,
0, 0, 411, 412, 5, 45, 0, 0, 412, 414, 3, 190, 95, 0, 413, 411, 1, 0, 0,
0, 413, 414, 1, 0, 0, 0, 414, 416, 1, 0, 0, 0, 415, 417, 3, 142, 71, 0,
416, 415, 1, 0, 0, 0, 416, 417, 1, 0, 0, 0, 417, 25, 1, 0, 0, 0, 418, 420,
5, 50, 0, 0, 419, 421, 7, 2, 0, 0, 420, 419, 1, 0, 0, 0, 420, 421, 1, 0,
0, 0, 421, 422, 1, 0, 0, 0, 422, 426, 5, 132, 0, 0, 423, 424, 5, 80, 0,
0, 424, 425, 5, 102, 0, 0, 425, 427, 5, 70, 0, 0, 426, 423, 1, 0, 0, 0,
426, 427, 1, 0, 0, 0, 427, 431, 1, 0, 0, 0, 428, 429, 3, 182, 91, 0, 429,
430, 5, 2, 0, 0, 430, 432, 1, 0, 0, 0, 431, 428, 1, 0, 0, 0, 431, 432,
1, 0, 0, 0, 432, 433, 1, 0, 0, 0, 433, 457, 3, 184, 92, 0, 434, 435, 5,
3, 0, 0, 435, 440, 3, 28, 14, 0, 436, 437, 5, 5, 0, 0, 437, 439, 3, 28,
14, 0, 438, 436, 1, 0, 0, 0, 439, 442, 1, 0, 0, 0, 440, 441, 1, 0, 0, 0,
440, 438, 1, 0, 0, 0, 441, 447, 1, 0, 0, 0, 442, 440, 1, 0, 0, 0, 443,
444, 5, 5, 0, 0, 444, 446, 3, 36, 18, 0, 445, 443, 1, 0, 0, 0, 446, 449,
1, 0, 0, 0, 447, 445, 1, 0, 0, 0, 447, 448, 1, 0, 0, 0, 448, 450, 1, 0,
0, 0, 449, 447, 1, 0, 0, 0, 450, 453, 5, 4, 0, 0, 451, 452, 5, 150, 0,
0, 452, 454, 5, 185, 0, 0, 453, 451, 1, 0, 0, 0, 453, 454, 1, 0, 0, 0,
454, 458, 1, 0, 0, 0, 455, 456, 5, 33, 0, 0, 456, 458, 3, 82, 41, 0, 457,
434, 1, 0, 0, 0, 457, 455, 1, 0, 0, 0, 458, 27, 1, 0, 0, 0, 459, 461, 3,
188, 94, 0, 460, 462, 3, 30, 15, 0, 461, 460, 1, 0, 0, 0, 461, 462, 1,
0, 0, 0, 462, 466, 1, 0, 0, 0, 463, 465, 3, 32, 16, 0, 464, 463, 1, 0,
0, 0, 465, 468, 1, 0, 0, 0, 466, 464, 1, 0, 0, 0, 466, 467, 1, 0, 0, 0,
467, 29, 1, 0, 0, 0, 468, 466, 1, 0, 0, 0, 469, 471, 3, 178, 89, 0, 470,
469, 1, 0, 0, 0, 471, 472, 1, 0, 0, 0, 472, 473, 1, 0, 0, 0, 472, 470,
1, 0, 0, 0, 473, 484, 1, 0, 0, 0, 474, 475, 5, 3, 0, 0, 475, 476, 3, 34,
17, 0, 476, 477, 5, 4, 0, 0, 477, 485, 1, 0, 0, 0, 478, 479, 5, 3, 0, 0,
479, 480, 3, 34, 17, 0, 480, 481, 5, 5, 0, 0, 481, 482, 3, 34, 17, 0, 482,
483, 5, 4, 0, 0, 483, 485, 1, 0, 0, 0, 484, 474, 1, 0, 0, 0, 484, 478,
1, 0, 0, 0, 484, 485, 1, 0, 0, 0, 485, 31, 1, 0, 0, 0, 486, 487, 5, 49,
0, 0, 487, 489, 3, 178, 89, 0, 488, 486, 1, 0, 0, 0, 488, 489, 1, 0, 0,
0, 489, 537, 1, 0, 0, 0, 490, 491, 5, 113, 0, 0, 491, 493, 5, 95, 0, 0,
492, 494, 3, 142, 71, 0, 493, 492, 1, 0, 0, 0, 493, 494, 1, 0, 0, 0, 494,
496, 1, 0, 0, 0, 495, 497, 3, 40, 20, 0, 496, 495, 1, 0, 0, 0, 496, 497,
1, 0, 0, 0, 497, 499, 1, 0, 0, 0, 498, 500, 5, 36, 0, 0, 499, 498, 1, 0,
0, 0, 499, 500, 1, 0, 0, 0, 500, 538, 1, 0, 0, 0, 501, 502, 5, 102, 0,
0, 502, 505, 5, 104, 0, 0, 503, 505, 5, 140, 0, 0, 504, 501, 1, 0, 0, 0,
504, 503, 1, 0, 0, 0, 505, 507, 1, 0, 0, 0, 506, 508, 3, 40, 20, 0, 507,
506, 1, 0, 0, 0, 507, 508, 1, 0, 0, 0, 508, 538, 1, 0, 0, 0, 509, 510,
5, 44, 0, 0, 510, 511, 5, 3, 0, 0, 511, 512, 3, 64, 32, 0, 512, 513, 5,
4, 0, 0, 513, 538, 1, 0, 0, 0, 514, 521, 5, 56, 0, 0, 515, 522, 3, 34,
17, 0, 516, 522, 3, 68, 34, 0, 517, 518, 5, 3, 0, 0, 518, 519, 3, 64, 32,
0, 519, 520, 5, 4, 0, 0, 520, 522, 1, 0, 0, 0, 521, 515, 1, 0, 0, 0, 521,
516, 1, 0, 0, 0, 521, 517, 1, 0, 0, 0, 522, 538, 1, 0, 0, 0, 523, 524,
5, 45, 0, 0, 524, 538, 3, 190, 95, 0, 525, 538, 3, 38, 19, 0, 526, 527,
5, 169, 0, 0, 527, 529, 5, 170, 0, 0, 528, 526, 1, 0, 0, 0, 528, 529, 1,
0, 0, 0, 529, 530, 1, 0, 0, 0, 530, 531, 5, 33, 0, 0, 531, 532, 5, 3, 0,
0, 532, 533, 3, 64, 32, 0, 533, 535, 5, 4, 0, 0, 534, 536, 7, 3, 0, 0,
535, 534, 1, 0, 0, 0, 535, 536, 1, 0, 0, 0, 536, 538, 1, 0, 0, 0, 537,
490, 1, 0, 0, 0, 537, 504, 1, 0, 0, 0, 537, 509, 1, 0, 0, 0, 537, 514,
1, 0, 0, 0, 537, 523, 1, 0, 0, 0, 537, 525, 1, 0, 0, 0, 537, 528, 1, 0,
0, 0, 538, 33, 1, 0, 0, 0, 539, 541, 7, 4, 0, 0, 540, 539, 1, 0, 0, 0,
540, 541, 1, 0, 0, 0, 541, 542, 1, 0, 0, 0, 542, 543, 5, 186, 0, 0, 543,
35, 1, 0, 0, 0, 544, 545, 5, 49, 0, 0, 545, 547, 3, 178, 89, 0, 546, 544,
1, 0, 0, 0, 546, 547, 1, 0, 0, 0, 547, 585, 1, 0, 0, 0, 548, 549, 5, 113,
0, 0, 549, 552, 5, 95, 0, 0, 550, 552, 5, 140, 0, 0, 551, 548, 1, 0, 0,
0, 551, 550, 1, 0, 0, 0, 552, 553, 1, 0, 0, 0, 553, 554, 5, 3, 0, 0, 554,
559, 3, 24, 12, 0, 555, 556, 5, 5, 0, 0, 556, 558, 3, 24, 12, 0, 557, 555,
1, 0, 0, 0, 558, 561, 1, 0, 0, 0, 559, 557, 1, 0, 0, 0, 559, 560, 1, 0,
0, 0, 560, 562, 1, 0, 0, 0, 561, 559, 1, 0, 0, 0, 562, 564, 5, 4, 0, 0,
563, 565, 3, 40, 20, 0, 564, 563, 1, 0, 0, 0, 564, 565, 1, 0, 0, 0, 565,
586, 1, 0, 0, 0, 566, 567, 5, 44, 0, 0, 567, 568, 5, 3, 0, 0, 568, 569,
3, 64, 32, 0, 569, 570, 5, 4, 0, 0, 570, 586, 1, 0, 0, 0, 571, 572, 5,
74, 0, 0, 572, 573, 5, 95, 0, 0, 573, 574, 5, 3, 0, 0, 574, 579, 3, 188,
94, 0, 575, 576, 5, 5, 0, 0, 576, 578, 3, 188, 94, 0, 577, 575, 1, 0, 0,
0, 578, 581, 1, 0, 0, 0, 579, 577, 1, 0, 0, 0, 579, 580, 1, 0, 0, 0, 580,
582, 1, 0, 0, 0, 581, 579, 1, 0, 0, 0, 582, 583, 5, 4, 0, 0, 583, 584,
3, 38, 19, 0, 584, 586, 1, 0, 0, 0, 585, 551, 1, 0, 0, 0, 585, 566, 1,
0, 0, 0, 585, 571, 1, 0, 0, 0, 586, 37, 1, 0, 0, 0, 587, 588, 5, 117, 0,
0, 588, 600, 3, 192, 96, 0, 589, 590, 5, 3, 0, 0, 590, 595, 3, 188, 94,
0, 591, 592, 5, 5, 0, 0, 592, 594, 3, 188, 94, 0, 593, 591, 1, 0, 0, 0,
594, 597, 1, 0, 0, 0, 595, 593, 1, 0, 0, 0, 595, 596, 1, 0, 0, 0, 596,
598, 1, 0, 0, 0, 597, 595, 1, 0, 0, 0, 598, 599, 5, 4, 0, 0, 599, 601,
1, 0, 0, 0, 600, 589, 1, 0, 0, 0, 600, 601, 1, 0, 0, 0, 601, 616, 1, 0,
0, 0, 602, 603, 5, 107, 0, 0, 603, 610, 7, 5, 0, 0, 604, 605, 5, 131, 0,
0, 605, 611, 7, 6, 0, 0, 606, 611, 5, 41, 0, 0, 607, 611, 5, 123, 0, 0,
608, 609, 5, 101, 0, 0, 609, 611, 5, 26, 0, 0, 610, 604, 1, 0, 0, 0, 610,
606, 1, 0, 0, 0, 610, 607, 1, 0, 0, 0, 610, 608, 1, 0, 0, 0, 611, 615,
1, 0, 0, 0, 612, 613, 5, 99, 0, 0, 613, 615, 3, 178, 89, 0, 614, 602, 1,
0, 0, 0, 614, 612, 1, 0, 0, 0, 615, 618, 1, 0, 0, 0, 616, 614, 1, 0, 0,
0, 616, 617, 1, 0, 0, 0, 617, 627, 1, 0, 0, 0, 618, 616, 1, 0, 0, 0, 619,
621, 5, 102, 0, 0, 620, 619, 1, 0, 0, 0, 620, 621, 1, 0, 0, 0, 621, 622,
1, 0, 0, 0, 622, 625, 5, 57, 0, 0, 623, 624, 5, 86, 0, 0, 624, 626, 7,
7, 0, 0, 625, 623, 1, 0, 0, 0, 625, 626, 1, 0, 0, 0, 626, 628, 1, 0, 0,
0, 627, 620, 1, 0, 0, 0, 627, 628, 1, 0, 0, 0, 628, 39, 1, 0, 0, 0, 629,
630, 5, 107, 0, 0, 630, 631, 5, 48, 0, 0, 631, 632, 7, 8, 0, 0, 632, 41,
1, 0, 0, 0, 633, 635, 5, 50, 0, 0, 634, 636, 7, 2, 0, 0, 635, 634, 1, 0,
0, 0, 635, 636, 1, 0, 0, 0, 636, 637, 1, 0, 0, 0, 637, 641, 5, 138, 0,
0, 638, 639, 5, 80, 0, 0, 639, 640, 5, 102, 0, 0, 640, 642, 5, 70, 0, 0,
641, 638, 1, 0, 0, 0, 641, 642, 1, 0, 0, 0, 642, 646, 1, 0, 0, 0, 643,
644, 3, 182, 91, 0, 644, 645, 5, 2, 0, 0, 645, 647, 1, 0, 0, 0, 646, 643,
1, 0, 0, 0, 646, 647, 1, 0, 0, 0, 647, 648, 1, 0, 0, 0, 648, 653, 3, 196,
98, 0, 649, 654, 5, 37, 0, 0, 650, 654, 5, 28, 0, 0, 651, 652, 5, 89, 0,
0, 652, 654, 5, 105, 0, 0, 653, 649, 1, 0, 0, 0, 653, 650, 1, 0, 0, 0,
653, 651, 1, 0, 0, 0, 653, 654, 1, 0, 0, 0, 654, 669, 1, 0, 0, 0, 655,
670, 5, 59, 0, 0, 656, 670, 5, 88, 0, 0, 657, 667, 5, 141, 0, 0, 658, 659,
5, 105, 0, 0, 659, 664, 3, 188, 94, 0, 660, 661, 5, 5, 0, 0, 661, 663,
3, 188, 94, 0, 662, 660, 1, 0, 0, 0, 663, 666, 1, 0, 0, 0, 664, 662, 1,
0, 0, 0, 664, 665, 1, 0, 0, 0, 665, 668, 1, 0, 0, 0, 666, 664, 1, 0, 0,
0, 667, 658, 1, 0, 0, 0, 667, 668, 1, 0, 0, 0, 668, 670, 1, 0, 0, 0, 669,
655, 1, 0, 0, 0, 669, 656, 1, 0, 0, 0, 669, 657, 1, 0, 0, 0, 670, 671,
1, 0, 0, 0, 671, 672, 5, 107, 0, 0, 672, 676, 3, 184, 92, 0, 673, 674,
5, 73, 0, 0, 674, 675, 5, 64, 0, 0, 675, 677, 5, 127, 0, 0, 676, 673, 1,
0, 0, 0, 676, 677, 1, 0, 0, 0, 677, 680, 1, 0, 0, 0, 678, 679, 5, 147,
0, 0, 679, 681, 3, 64, 32, 0, 680, 678, 1, 0, 0, 0, 680, 681, 1, 0, 0,
0, 681, 682, 1, 0, 0, 0, 682, 691, 5, 38, 0, 0, 683, 688, 3, 104, 52, 0,
684, 688, 3, 70, 35, 0, 685, 688, 3, 56, 28, 0, 686, 688, 3, 82, 41, 0,
687, 683, 1, 0, 0, 0, 687, 684, 1, 0, 0, 0, 687, 685, 1, 0, 0, 0, 687,
686, 1, 0, 0, 0, 688, 689, 1, 0, 0, 0, 689, 690, 5, 1, 0, 0, 690, 692,
1, 0, 0, 0, 691, 687, 1, 0, 0, 0, 692, 693, 1, 0, 0, 0, 693, 691, 1, 0,
0, 0, 693, 694, 1, 0, 0, 0, 694, 695, 1, 0, 0, 0, 695, 696, 5, 66, 0, 0,
696, 43, 1, 0, 0, 0, 697, 699, 5, 50, 0, 0, 698, 700, 7, 2, 0, 0, 699,
698, 1, 0, 0, 0, 699, 700, 1, 0, 0, 0, 700, 701, 1, 0, 0, 0, 701, 705,
5, 145, 0, 0, 702, 703, 5, 80, 0, 0, 703, 704, 5, 102, 0, 0, 704, 706,
5, 70, 0, 0, 705, 702, 1, 0, 0, 0, 705, 706, 1, 0, 0, 0, 706, 710, 1, 0,
0, 0, 707, 708, 3, 182, 91, 0, 708, 709, 5, 2, 0, 0, 709, 711, 1, 0, 0,
0, 710, 707, 1, 0, 0, 0, 710, 711, 1, 0, 0, 0, 711, 712, 1, 0, 0, 0, 712,
724, 3, 198, 99, 0, 713, 714, 5, 3, 0, 0, 714, 719, 3, 188, 94, 0, 715,
716, 5, 5, 0, 0, 716, 718, 3, 188, 94, 0, 717, 715, 1, 0, 0, 0, 718, 721,
1, 0, 0, 0, 719, 717, 1, 0, 0, 0, 719, 720, 1, 0, 0, 0, 720, 722, 1, 0,
0, 0, 721, 719, 1, 0, 0, 0, 722, 723, 5, 4, 0, 0, 723, 725, 1, 0, 0, 0,
724, 713, 1, 0, 0, 0, 724, 725, 1, 0, 0, 0, 725, 726, 1, 0, 0, 0, 726,
727, 5, 33, 0, 0, 727, 728, 3, 82, 41, 0, 728, 45, 1, 0, 0, 0, 729, 730,
5, 50, 0, 0, 730, 731, 5, 146, 0, 0, 731, 735, 5, 132, 0, 0, 732, 733,
5, 80, 0, 0, 733, 734, 5, 102, 0, 0, 734, 736, 5, 70, 0, 0, 735, 732, 1,
0, 0, 0, 735, 736, 1, 0, 0, 0, 736, 740, 1, 0, 0, 0, 737, 738, 3, 182,
91, 0, 738, 739, 5, 2, 0, 0, 739, 741, 1, 0, 0, 0, 740, 737, 1, 0, 0, 0,
740, 741, 1, 0, 0, 0, 741, 742, 1, 0, 0, 0, 742, 743, 3, 184, 92, 0, 743,
744, 5, 142, 0, 0, 744, 756, 3, 200, 100, 0, 745, 746, 5, 3, 0, 0, 746,
751, 3, 172, 86, 0, 747, 748, 5, 5, 0, 0, 748, 750, 3, 172, 86, 0, 749,
747, 1, 0, 0, 0, 750, 753, 1, 0, 0, 0, 751, 749, 1, 0, 0, 0, 751, 752,
1, 0, 0, 0, 752, 754, 1, 0, 0, 0, 753, 751, 1, 0, 0, 0, 754, 755, 5, 4,
0, 0, 755, 757, 1, 0, 0, 0, 756, 745, 1, 0, 0, 0, 756, 757, 1, 0, 0, 0,
757, 47, 1, 0, 0, 0, 758, 760, 5, 149, 0, 0, 759, 761, 5, 116, 0, 0, 760,
759, 1, 0, 0, 0, 760, 761, 1, 0, 0, 0, 761, 762, 1, 0, 0, 0, 762, 763,
3, 50, 25, 0, 763, 764, 5, 33, 0, 0, 764, 765, 5, 3, 0, 0, 765, 766, 3,
82, 41, 0, 766, 776, 5, 4, 0, 0, 767, 768, 5, 5, 0, 0, 768, 769, 3, 50,
25, 0, 769, 770, 5, 33, 0, 0, 770, 771, 5, 3, 0, 0, 771, 772, 3, 82, 41,
0, 772, 773, 5, 4, 0, 0, 773, 775, 1, 0, 0, 0, 774, 767, 1, 0, 0, 0, 775,
778, 1, 0, 0, 0, 776, 774, 1, 0, 0, 0, 776, 777, 1, 0, 0, 0, 777, 49, 1,
0, 0, 0, 778, 776, 1, 0, 0, 0, 779, 791, 3, 184, 92, 0, 780, 781, 5, 3,
0, 0, 781, 786, 3, 188, 94, 0, 782, 783, 5, 5, 0, 0, 783, 785, 3, 188,
94, 0, 784, 782, 1, 0, 0, 0, 785, 788, 1, 0, 0, 0, 786, 784, 1, 0, 0, 0,
786, 787, 1, 0, 0, 0, 787, 789, 1, 0, 0, 0, 788, 786, 1, 0, 0, 0, 789,
790, 5, 4, 0, 0, 790, 792, 1, 0, 0, 0, 791, 780, 1, 0, 0, 0, 791, 792,
1, 0, 0, 0, 792, 51, 1, 0, 0, 0, 793, 794, 3, 50, 25, 0, 794, 795, 5, 33,
0, 0, 795, 796, 5, 3, 0, 0, 796, 797, 3, 164, 82, 0, 797, 799, 5, 139,
0, 0, 798, 800, 5, 29, 0, 0, 799, 798, 1, 0, 0, 0, 799, 800, 1, 0, 0, 0,
800, 801, 1, 0, 0, 0, 801, 802, 3, 166, 83, 0, 802, 803, 5, 4, 0, 0, 803,
53, 1, 0, 0, 0, 804, 816, 3, 184, 92, 0, 805, 806, 5, 3, 0, 0, 806, 811,
3, 188, 94, 0, 807, 808, 5, 5, 0, 0, 808, 810, 3, 188, 94, 0, 809, 807,
1, 0, 0, 0, 810, 813, 1, 0, 0, 0, 811, 809, 1, 0, 0, 0, 811, 812, 1, 0,
0, 0, 812, 814, 1, 0, 0, 0, 813, 811, 1, 0, 0, 0, 814, 815, 5, 4, 0, 0,
815, 817, 1, 0, 0, 0, 816, 805, 1, 0, 0, 0, 816, 817, 1, 0, 0, 0, 817,
818, 1, 0, 0, 0, 818, 819, 5, 33, 0, 0, 819, 820, 5, 3, 0, 0, 820, 821,
3, 82, 41, 0, 821, 822, 5, 4, 0, 0, 822, 55, 1, 0, 0, 0, 823, 825, 3, 48,
24, 0, 824, 823, 1, 0, 0, 0, 824, 825, 1, 0, 0, 0, 825, 826, 1, 0, 0, 0,
826, 827, 5, 59, 0, 0, 827, 828, 5, 75, 0, 0, 828, 831, 3, 114, 57, 0,
829, 830, 5, 148, 0, 0, 830, 832, 3, 64, 32, 0, 831, 829, 1, 0, 0, 0, 831,
832, 1, 0, 0, 0, 832, 834, 1, 0, 0, 0, 833, 835, 3, 72, 36, 0, 834, 833,
1, 0, 0, 0, 834, 835, 1, 0, 0, 0, 835, 57, 1, 0, 0, 0, 836, 838, 3, 48,
24, 0, 837, 836, 1, 0, 0, 0, 837, 838, 1, 0, 0, 0, 838, 839, 1, 0, 0, 0,
839, 840, 5, 59, 0, 0, 840, 841, 5, 75, 0, 0, 841, 844, 3, 114, 57, 0,
842, 843, 5, 148, 0, 0, 843, 845, 3, 64, 32, 0, 844, 842, 1, 0, 0, 0, 844,
845, 1, 0, 0, 0, 845, 847, 1, 0, 0, 0, 846, 848, 3, 72, 36, 0, 847, 846,
1, 0, 0, 0, 847, 848, 1, 0, 0, 0, 848, 853, 1, 0, 0, 0, 849, 851, 3, 136,
68, 0, 850, 849, 1, 0, 0, 0, 850, 851, 1, 0, 0, 0, 851, 852, 1, 0, 0, 0,
852, 854, 3, 138, 69, 0, 853, 850, 1, 0, 0, 0, 853, 854, 1, 0, 0, 0, 854,
59, 1, 0, 0, 0, 855, 857, 5, 61, 0, 0, 856, 858, 5, 55, 0, 0, 857, 856,
1, 0, 0, 0, 857, 858, 1, 0, 0, 0, 858, 859, 1, 0, 0, 0, 859, 860, 3, 182,
91, 0, 860, 61, 1, 0, 0, 0, 861, 862, 5, 63, 0, 0, 862, 865, 7, 9, 0, 0,
863, 864, 5, 80, 0, 0, 864, 866, 5, 70, 0, 0, 865, 863, 1, 0, 0, 0, 865,
866, 1, 0, 0, 0, 866, 870, 1, 0, 0, 0, 867, 868, 3, 182, 91, 0, 868, 869,
5, 2, 0, 0, 869, 871, 1, 0, 0, 0, 870, 867, 1, 0, 0, 0, 870, 871, 1, 0,
0, 0, 871, 872, 1, 0, 0, 0, 872, 873, 3, 224, 112, 0, 873, 63, 1, 0, 0,
0, 874, 875, 6, 32, -1, 0, 875, 963, 3, 68, 34, 0, 876, 963, 5, 187, 0,
0, 877, 878, 3, 182, 91, 0, 878, 879, 5, 2, 0, 0, 879, 881, 1, 0, 0, 0,
880, 877, 1, 0, 0, 0, 880, 881, 1, 0, 0, 0, 881, 882, 1, 0, 0, 0, 882,
883, 3, 184, 92, 0, 883, 884, 5, 2, 0, 0, 884, 886, 1, 0, 0, 0, 885, 880,
1, 0, 0, 0, 885, 886, 1, 0, 0, 0, 886, 887, 1, 0, 0, 0, 887, 963, 3, 188,
94, 0, 888, 889, 3, 168, 84, 0, 889, 890, 3, 64, 32, 21, 890, 963, 1, 0,
0, 0, 891, 892, 3, 180, 90, 0, 892, 905, 5, 3, 0, 0, 893, 895, 5, 62, 0,
0, 894, 893, 1, 0, 0, 0, 894, 895, 1, 0, 0, 0, 895, 896, 1, 0, 0, 0, 896,
901, 3, 64, 32, 0, 897, 898, 5, 5, 0, 0, 898, 900, 3, 64, 32, 0, 899, 897,
1, 0, 0, 0, 900, 903, 1, 0, 0, 0, 901, 899, 1, 0, 0, 0, 901, 902, 1, 0,
0, 0, 902, 906, 1, 0, 0, 0, 903, 901, 1, 0, 0, 0, 904, 906, 5, 7, 0, 0,
905, 894, 1, 0, 0, 0, 905, 904, 1, 0, 0, 0, 905, 906, 1, 0, 0, 0, 906,
907, 1, 0, 0, 0, 907, 909, 5, 4, 0, 0, 908, 910, 3, 118, 59, 0, 909, 908,
1, 0, 0, 0, 909, 910, 1, 0, 0, 0, 910, 912, 1, 0, 0, 0, 911, 913, 3, 122,
61, 0, 912, 911, 1, 0, 0, 0, 912, 913, 1, 0, 0, 0, 913, 963, 1, 0, 0, 0,
914, 915, 5, 3, 0, 0, 915, 920, 3, 64, 32, 0, 916, 917, 5, 5, 0, 0, 917,
919, 3, 64, 32, 0, 918, 916, 1, 0, 0, 0, 919, 922, 1, 0, 0, 0, 920, 918,
1, 0, 0, 0, 920, 921, 1, 0, 0, 0, 921, 923, 1, 0, 0, 0, 922, 920, 1, 0,
0, 0, 923, 924, 5, 4, 0, 0, 924, 963, 1, 0, 0, 0, 925, 926, 5, 43, 0, 0,
926, 927, 5, 3, 0, 0, 927, 928, 3, 64, 32, 0, 928, 929, 5, 33, 0, 0, 929,
930, 3, 30, 15, 0, 930, 931, 5, 4, 0, 0, 931, 963, 1, 0, 0, 0, 932, 934,
5, 102, 0, 0, 933, 932, 1, 0, 0, 0, 933, 934, 1, 0, 0, 0, 934, 935, 1,
0, 0, 0, 935, 937, 5, 70, 0, 0, 936, 933, 1, 0, 0, 0, 936, 937, 1, 0, 0,
0, 937, 938, 1, 0, 0, 0, 938, 939, 5, 3, 0, 0, 939, 940, 3, 82, 41, 0,
940, 941, 5, 4, 0, 0, 941, 963, 1, 0, 0, 0, 942, 944, 5, 42, 0, 0, 943,
945, 3, 64, 32, 0, 944, 943, 1, 0, 0, 0, 944, 945, 1, 0, 0, 0, 945, 951,
1, 0, 0, 0, 946, 947, 5, 147, 0, 0, 947, 948, 3, 64, 32, 0, 948, 949, 5,
135, 0, 0, 949, 950, 3, 64, 32, 0, 950, 952, 1, 0, 0, 0, 951, 946, 1, 0,
0, 0, 952, 953, 1, 0, 0, 0, 953, 951, 1, 0, 0, 0, 953, 954, 1, 0, 0, 0,
954, 957, 1, 0, 0, 0, 955, 956, 5, 65, 0, 0, 956, 958, 3, 64, 32, 0, 957,
955, 1, 0, 0, 0, 957, 958, 1, 0, 0, 0, 958, 959, 1, 0, 0, 0, 959, 960,
5, 66, 0, 0, 960, 963, 1, 0, 0, 0, 961, 963, 3, 66, 33, 0, 962, 874, 1,
0, 0, 0, 962, 876, 1, 0, 0, 0, 962, 885, 1, 0, 0, 0, 962, 888, 1, 0, 0,
0, 962, 891, 1, 0, 0, 0, 962, 914, 1, 0, 0, 0, 962, 925, 1, 0, 0, 0, 962,
936, 1, 0, 0, 0, 962, 942, 1, 0, 0, 0, 962, 961, 1, 0, 0, 0, 963, 1083,
1, 0, 0, 0, 964, 965, 10, 20, 0, 0, 965, 966, 5, 11, 0, 0, 966, 1082, 3,
64, 32, 21, 967, 968, 10, 19, 0, 0, 968, 969, 7, 10, 0, 0, 969, 1082, 3,
64, 32, 20, 970, 971, 10, 18, 0, 0, 971, 972, 7, 4, 0, 0, 972, 1082, 3,
64, 32, 19, 973, 974, 10, 17, 0, 0, 974, 975, 7, 11, 0, 0, 975, 1082, 3,
64, 32, 18, 976, 977, 10, 16, 0, 0, 977, 978, 7, 12, 0, 0, 978, 1082, 3,
64, 32, 17, 979, 992, 10, 15, 0, 0, 980, 993, 5, 6, 0, 0, 981, 993, 5,
22, 0, 0, 982, 993, 5, 23, 0, 0, 983, 993, 5, 24, 0, 0, 984, 993, 5, 92,
0, 0, 985, 986, 5, 92, 0, 0, 986, 993, 5, 102, 0, 0, 987, 993, 5, 83, 0,
0, 988, 993, 5, 97, 0, 0, 989, 993, 5, 77, 0, 0, 990, 993, 5, 99, 0, 0,
991, 993, 5, 118, 0, 0, 992, 980, 1, 0, 0, 0, 992, 981, 1, 0, 0, 0, 992,
982, 1, 0, 0, 0, 992, 983, 1, 0, 0, 0, 992, 984, 1, 0, 0, 0, 992, 985,
1, 0, 0, 0, 992, 987, 1, 0, 0, 0, 992, 988, 1, 0, 0, 0, 992, 989, 1, 0,
0, 0, 992, 990, 1, 0, 0, 0, 992, 991, 1, 0, 0, 0, 993, 994, 1, 0, 0, 0,
994, 1082, 3, 64, 32, 16, 995, 996, 10, 14, 0, 0, 996, 997, 5, 32, 0, 0,
997, 1082, 3, 64, 32, 15, 998, 999, 10, 13, 0, 0, 999, 1000, 5, 108, 0,
0, 1000, 1082, 3, 64, 32, 14, 1001, 1002, 10, 6, 0, 0, 1002, 1004, 5, 92,
0, 0, 1003, 1005, 5, 102, 0, 0, 1004, 1003, 1, 0, 0, 0, 1004, 1005, 1,
0, 0, 0, 1005, 1006, 1, 0, 0, 0, 1006, 1082, 3, 64, 32, 7, 1007, 1009,
10, 5, 0, 0, 1008, 1010, 5, 102, 0, 0, 1009, 1008, 1, 0, 0, 0, 1009, 1010,
1, 0, 0, 0, 1010, 1011, 1, 0, 0, 0, 1011, 1012, 5, 39, 0, 0, 1012, 1013,
3, 64, 32, 0, 1013, 1014, 5, 32, 0, 0, 1014, 1015, 3, 64, 32, 6, 1015,
1082, 1, 0, 0, 0, 1016, 1017, 10, 9, 0, 0, 1017, 1018, 5, 45, 0, 0, 1018,
1082, 3, 190, 95, 0, 1019, 1021, 10, 8, 0, 0, 1020, 1022, 5, 102, 0, 0,
1021, 1020, 1, 0, 0, 0, 1021, 1022, 1, 0, 0, 0, 1022, 1023, 1, 0, 0, 0,
1023, 1024, 7, 13, 0, 0, 1024, 1027, 3, 64, 32, 0, 1025, 1026, 5, 67, 0,
0, 1026, 1028, 3, 64, 32, 0, 1027, 1025, 1, 0, 0, 0, 1027, 1028, 1, 0,
0, 0, 1028, 1082, 1, 0, 0, 0, 1029, 1034, 10, 7, 0, 0, 1030, 1035, 5, 93,
0, 0, 1031, 1035, 5, 103, 0, 0, 1032, 1033, 5, 102, 0, 0, 1033, 1035, 5,
104, 0, 0, 1034, 1030, 1, 0, 0, 0, 1034, 1031, 1, 0, 0, 0, 1034, 1032,
1, 0, 0, 0, 1035, 1082, 1, 0, 0, 0, 1036, 1038, 10, 4, 0, 0, 1037, 1039,
5, 102, 0, 0, 1038, 1037, 1, 0, 0, 0, 1038, 1039, 1, 0, 0, 0, 1039, 1040,
1, 0, 0, 0, 1040, 1079, 5, 83, 0, 0, 1041, 1051, 5, 3, 0, 0, 1042, 1052,
3, 82, 41, 0, 1043, 1048, 3, 64, 32, 0, 1044, 1045, 5, 5, 0, 0, 1045, 1047,
3, 64, 32, 0, 1046, 1044, 1, 0, 0, 0, 1047, 1050, 1, 0, 0, 0, 1048, 1046,
1, 0, 0, 0, 1048, 1049, 1, 0, 0, 0, 1049, 1052, 1, 0, 0, 0, 1050, 1048,
1, 0, 0, 0, 1051, 1042, 1, 0, 0, 0, 1051, 1043, 1, 0, 0, 0, 1051, 1052,
1, 0, 0, 0, 1052, 1053, 1, 0, 0, 0, 1053, 1080, 5, 4, 0, 0, 1054, 1055,
3, 182, 91, 0, 1055, 1056, 5, 2, 0, 0, 1056, 1058, 1, 0, 0, 0, 1057, 1054,
1, 0, 0, 0, 1057, 1058, 1, 0, 0, 0, 1058, 1059, 1, 0, 0, 0, 1059, 1080,
3, 184, 92, 0, 1060, 1061, 3, 182, 91, 0, 1061, 1062, 5, 2, 0, 0, 1062,
1064, 1, 0, 0, 0, 1063, 1060, 1, 0, 0, 0, 1063, 1064, 1, 0, 0, 0, 1064,
1065, 1, 0, 0, 0, 1065, 1066, 3, 222, 111, 0, 1066, 1075, 5, 3, 0, 0, 1067,
1072, 3, 64, 32, 0, 1068, 1069, 5, 5, 0, 0, 1069, 1071, 3, 64, 32, 0, 1070,
1068, 1, 0, 0, 0, 1071, 1074, 1, 0, 0, 0, 1072, 1070, 1, 0, 0, 0, 1072,
1073, 1, 0, 0, 0, 1073, 1076, 1, 0, 0, 0, 1074, 1072, 1, 0, 0, 0, 1075,
1067, 1, 0, 0, 0, 1075, 1076, 1, 0, 0, 0, 1076, 1077, 1, 0, 0, 0, 1077,
1078, 5, 4, 0, 0, 1078, 1080, 1, 0, 0, 0, 1079, 1041, 1, 0, 0, 0, 1079,
1057, 1, 0, 0, 0, 1079, 1063, 1, 0, 0, 0, 1080, 1082, 1, 0, 0, 0, 1081,
964, 1, 0, 0, 0, 1081, 967, 1, 0, 0, 0, 1081, 970, 1, 0, 0, 0, 1081, 973,
1, 0, 0, 0, 1081, 976, 1, 0, 0, 0, 1081, 979, 1, 0, 0, 0, 1081, 995, 1,
0, 0, 0, 1081, 998, 1, 0, 0, 0, 1081, 1001, 1, 0, 0, 0, 1081, 1007, 1,
0, 0, 0, 1081, 1016, 1, 0, 0, 0, 1081, 1019, 1, 0, 0, 0, 1081, 1029, 1,
0, 0, 0, 1081, 1036, 1, 0, 0, 0, 1082, 1085, 1, 0, 0, 0, 1083, 1081, 1,
0, 0, 0, 1083, 1084, 1, 0, 0, 0, 1084, 65, 1, 0, 0, 0, 1085, 1083, 1, 0,
0, 0, 1086, 1087, 5, 115, 0, 0, 1087, 1092, 5, 3, 0, 0, 1088, 1093, 5,
81, 0, 0, 1089, 1090, 7, 14, 0, 0, 1090, 1091, 5, 5, 0, 0, 1091, 1093,
3, 170, 85, 0, 1092, 1088, 1, 0, 0, 0, 1092, 1089, 1, 0, 0, 0, 1093, 1094,
1, 0, 0, 0, 1094, 1095, 5, 4, 0, 0, 1095, 67, 1, 0, 0, 0, 1096, 1097, 7,
15, 0, 0, 1097, 69, 1, 0, 0, 0, 1098, 1100, 3, 48, 24, 0, 1099, 1098, 1,
0, 0, 0, 1099, 1100, 1, 0, 0, 0, 1100, 1106, 1, 0, 0, 0, 1101, 1107, 5,
88, 0, 0, 1102, 1107, 5, 122, 0, 0, 1103, 1104, 5, 88, 0, 0, 1104, 1105,
5, 108, 0, 0, 1105, 1107, 7, 8, 0, 0, 1106, 1101, 1, 0, 0, 0, 1106, 1102,
1, 0, 0, 0, 1106, 1103, 1, 0, 0, 0, 1107, 1108, 1, 0, 0, 0, 1108, 1112,
5, 91, 0, 0, 1109, 1110, 3, 182, 91, 0, 1110, 1111, 5, 2, 0, 0, 1111, 1113,
1, 0, 0, 0, 1112, 1109, 1, 0, 0, 0, 1112, 1113, 1, 0, 0, 0, 1113, 1114,
1, 0, 0, 0, 1114, 1117, 3, 184, 92, 0, 1115, 1116, 5, 33, 0, 0, 1116, 1118,
3, 206, 103, 0, 1117, 1115, 1, 0, 0, 0, 1117, 1118, 1, 0, 0, 0, 1118, 1130,
1, 0, 0, 0, 1119, 1120, 5, 3, 0, 0, 1120, 1125, 3, 188, 94, 0, 1121, 1122,
5, 5, 0, 0, 1122, 1124, 3, 188, 94, 0, 1123, 1121, 1, 0, 0, 0, 1124, 1127,
1, 0, 0, 0, 1125, 1123, 1, 0, 0, 0, 1125, 1126, 1, 0, 0, 0, 1126, 1128,
1, 0, 0, 0, 1127, 1125, 1, 0, 0, 0, 1128, 1129, 5, 4, 0, 0, 1129, 1131,
1, 0, 0, 0, 1130, 1119, 1, 0, 0, 0, 1130, 1131, 1, 0, 0, 0, 1131, 1168,
1, 0, 0, 0, 1132, 1133, 5, 144, 0, 0, 1133, 1134, 5, 3, 0, 0, 1134, 1139,
3, 64, 32, 0, 1135, 1136, 5, 5, 0, 0, 1136, 1138, 3, 64, 32, 0, 1137, 1135,
1, 0, 0, 0, 1138, 1141, 1, 0, 0, 0, 1139, 1137, 1, 0, 0, 0, 1139, 1140,
1, 0, 0, 0, 1140, 1142, 1, 0, 0, 0, 1141, 1139, 1, 0, 0, 0, 1142, 1157,
5, 4, 0, 0, 1143, 1144, 5, 5, 0, 0, 1144, 1145, 5, 3, 0, 0, 1145, 1150,
3, 64, 32, 0, 1146, 1147, 5, 5, 0, 0, 1147, 1149, 3, 64, 32, 0, 1148, 1146,
1, 0, 0, 0, 1149, 1152, 1, 0, 0, 0, 1150, 1148, 1, 0, 0, 0, 1150, 1151,
1, 0, 0, 0, 1151, 1153, 1, 0, 0, 0, 1152, 1150, 1, 0, 0, 0, 1153, 1154,
5, 4, 0, 0, 1154, 1156, 1, 0, 0, 0, 1155, 1143, 1, 0, 0, 0, 1156, 1159,
1, 0, 0, 0, 1157, 1155, 1, 0, 0, 0, 1157, 1158, 1, 0, 0, 0, 1158, 1162,
1, 0, 0, 0, 1159, 1157, 1, 0, 0, 0, 1160, 1162, 3, 82, 41, 0, 1161, 1132,
1, 0, 0, 0, 1161, 1160, 1, 0, 0, 0, 1162, 1164, 1, 0, 0, 0, 1163, 1165,
3, 74, 37, 0, 1164, 1163, 1, 0, 0, 0, 1164, 1165, 1, 0, 0, 0, 1165, 1169,
1, 0, 0, 0, 1166, 1167, 5, 56, 0, 0, 1167, 1169, 5, 144, 0, 0, 1168, 1161,
1, 0, 0, 0, 1168, 1166, 1, 0, 0, 0, 1169, 1171, 1, 0, 0, 0, 1170, 1172,
3, 72, 36, 0, 1171, 1170, 1, 0, 0, 0, 1171, 1172, 1, 0, 0, 0, 1172, 71,
1, 0, 0, 0, 1173, 1174, 5, 124, 0, 0, 1174, 1179, 3, 96, 48, 0, 1175, 1176,
5, 5, 0, 0, 1176, 1178, 3, 96, 48, 0, 1177, 1175, 1, 0, 0, 0, 1178, 1181,
1, 0, 0, 0, 1179, 1177, 1, 0, 0, 0, 1179, 1180, 1, 0, 0, 0, 1180, 73, 1,
0, 0, 0, 1181, 1179, 1, 0, 0, 0, 1182, 1183, 5, 107, 0, 0, 1183, 1198,
5, 48, 0, 0, 1184, 1185, 5, 3, 0, 0, 1185, 1190, 3, 24, 12, 0, 1186, 1187,
5, 5, 0, 0, 1187, 1189, 3, 24, 12, 0, 1188, 1186, 1, 0, 0, 0, 1189, 1192,
1, 0, 0, 0, 1190, 1188, 1, 0, 0, 0, 1190, 1191, 1, 0, 0, 0, 1191, 1193,
1, 0, 0, 0, 1192, 1190, 1, 0, 0, 0, 1193, 1196, 5, 4, 0, 0, 1194, 1195,
5, 148, 0, 0, 1195, 1197, 3, 64, 32, 0, 1196, 1194, 1, 0, 0, 0, 1196, 1197,
1, 0, 0, 0, 1197, 1199, 1, 0, 0, 0, 1198, 1184, 1, 0, 0, 0, 1198, 1199,
1, 0, 0, 0, 1199, 1200, 1, 0, 0, 0, 1200, 1227, 5, 183, 0, 0, 1201, 1228,
5, 184, 0, 0, 1202, 1203, 5, 141, 0, 0, 1203, 1206, 5, 131, 0, 0, 1204,
1207, 3, 188, 94, 0, 1205, 1207, 3, 110, 55, 0, 1206, 1204, 1, 0, 0, 0,
1206, 1205, 1, 0, 0, 0, 1207, 1208, 1, 0, 0, 0, 1208, 1209, 5, 6, 0, 0,
1209, 1220, 3, 64, 32, 0, 1210, 1213, 5, 5, 0, 0, 1211, 1214, 3, 188, 94,
0, 1212, 1214, 3, 110, 55, 0, 1213, 1211, 1, 0, 0, 0, 1213, 1212, 1, 0,
0, 0, 1214, 1215, 1, 0, 0, 0, 1215, 1216, 5, 6, 0, 0, 1216, 1217, 3, 64,
32, 0, 1217, 1219, 1, 0, 0, 0, 1218, 1210, 1, 0, 0, 0, 1219, 1222, 1, 0,
0, 0, 1220, 1218, 1, 0, 0, 0, 1220, 1221, 1, 0, 0, 0, 1221, 1225, 1, 0,
0, 0, 1222, 1220, 1, 0, 0, 0, 1223, 1224, 5, 148, 0, 0, 1224, 1226, 3,
64, 32, 0, 1225, 1223, 1, 0, 0, 0, 1225, 1226, 1, 0, 0, 0, 1226, 1228,
1, 0, 0, 0, 1227, 1201, 1, 0, 0, 0, 1227, 1202, 1, 0, 0, 0, 1228, 75, 1,
0, 0, 0, 1229, 1233, 5, 112, 0, 0, 1230, 1231, 3, 182, 91, 0, 1231, 1232,
5, 2, 0, 0, 1232, 1234, 1, 0, 0, 0, 1233, 1230, 1, 0, 0, 0, 1233, 1234,
1, 0, 0, 0, 1234, 1235, 1, 0, 0, 0, 1235, 1242, 3, 202, 101, 0, 1236, 1237,
5, 6, 0, 0, 1237, 1243, 3, 78, 39, 0, 1238, 1239, 5, 3, 0, 0, 1239, 1240,
3, 78, 39, 0, 1240, 1241, 5, 4, 0, 0, 1241, 1243, 1, 0, 0, 0, 1242, 1236,
1, 0, 0, 0, 1242, 1238, 1, 0, 0, 0, 1242, 1243, 1, 0, 0, 0, 1243, 77, 1,
0, 0, 0, 1244, 1248, 3, 34, 17, 0, 1245, 1248, 3, 178, 89, 0, 1246, 1248,
5, 188, 0, 0, 1247, 1244, 1, 0, 0, 0, 1247, 1245, 1, 0, 0, 0, 1247, 1246,
1, 0, 0, 0, 1248, 79, 1, 0, 0, 0, 1249, 1260, 5, 119, 0, 0, 1250, 1261,
3, 190, 95, 0, 1251, 1252, 3, 182, 91, 0, 1252, 1253, 5, 2, 0, 0, 1253,
1255, 1, 0, 0, 0, 1254, 1251, 1, 0, 0, 0, 1254, 1255, 1, 0, 0, 0, 1255,
1258, 1, 0, 0, 0, 1256, 1259, 3, 184, 92, 0, 1257, 1259, 3, 194, 97, 0,
1258, 1256, 1, 0, 0, 0, 1258, 1257, 1, 0, 0, 0, 1259, 1261, 1, 0, 0, 0,
1260, 1250, 1, 0, 0, 0, 1260, 1254, 1, 0, 0, 0, 1260, 1261, 1, 0, 0, 0,
1261, 81, 1, 0, 0, 0, 1262, 1264, 3, 134, 67, 0, 1263, 1262, 1, 0, 0, 0,
1263, 1264, 1, 0, 0, 0, 1264, 1265, 1, 0, 0, 0, 1265, 1271, 3, 86, 43,
0, 1266, 1267, 3, 102, 51, 0, 1267, 1268, 3, 86, 43, 0, 1268, 1270, 1,
0, 0, 0, 1269, 1266, 1, 0, 0, 0, 1270, 1273, 1, 0, 0, 0, 1271, 1269, 1,
0, 0, 0, 1271, 1272, 1, 0, 0, 0, 1272, 1275, 1, 0, 0, 0, 1273, 1271, 1,
0, 0, 0, 1274, 1276, 3, 136, 68, 0, 1275, 1274, 1, 0, 0, 0, 1275, 1276,
1, 0, 0, 0, 1276, 1278, 1, 0, 0, 0, 1277, 1279, 3, 138, 69, 0, 1278, 1277,
1, 0, 0, 0, 1278, 1279, 1, 0, 0, 0, 1279, 83, 1, 0, 0, 0, 1280, 1288, 3,
94, 47, 0, 1281, 1282, 3, 98, 49, 0, 1282, 1284, 3, 94, 47, 0, 1283, 1285,
3, 100, 50, 0, 1284, 1283, 1, 0, 0, 0, 1284, 1285, 1, 0, 0, 0, 1285, 1287,
1, 0, 0, 0, 1286, 1281, 1, 0, 0, 0, 1287, 1290, 1, 0, 0, 0, 1288, 1286,
1, 0, 0, 0, 1288, 1289, 1, 0, 0, 0, 1289, 85, 1, 0, 0, 0, 1290, 1288, 1,
0, 0, 0, 1291, 1293, 5, 130, 0, 0, 1292, 1294, 7, 16, 0, 0, 1293, 1292,
1, 0, 0, 0, 1293, 1294, 1, 0, 0, 0, 1294, 1295, 1, 0, 0, 0, 1295, 1300,
3, 96, 48, 0, 1296, 1297, 5, 5, 0, 0, 1297, 1299, 3, 96, 48, 0, 1298, 1296,
1, 0, 0, 0, 1299, 1302, 1, 0, 0, 0, 1300, 1298, 1, 0, 0, 0, 1300, 1301,
1, 0, 0, 0, 1301, 1315, 1, 0, 0, 0, 1302, 1300, 1, 0, 0, 0, 1303, 1313,
5, 75, 0, 0, 1304, 1309, 3, 94, 47, 0, 1305, 1306, 5, 5, 0, 0, 1306, 1308,
3, 94, 47, 0, 1307, 1305, 1, 0, 0, 0, 1308, 1311, 1, 0, 0, 0, 1309, 1307,
1, 0, 0, 0, 1309, 1310, 1, 0, 0, 0, 1310, 1314, 1, 0, 0, 0, 1311, 1309,
1, 0, 0, 0, 1312, 1314, 3, 84, 42, 0, 1313, 1304, 1, 0, 0, 0, 1313, 1312,
1, 0, 0, 0, 1314, 1316, 1, 0, 0, 0, 1315, 1303, 1, 0, 0, 0, 1315, 1316,
1, 0, 0, 0, 1316, 1319, 1, 0, 0, 0, 1317, 1318, 5, 148, 0, 0, 1318, 1320,
3, 64, 32, 0, 1319, 1317, 1, 0, 0, 0, 1319, 1320, 1, 0, 0, 0, 1320, 1335,
1, 0, 0, 0, 1321, 1322, 5, 78, 0, 0, 1322, 1323, 5, 40, 0, 0, 1323, 1328,
3, 64, 32, 0, 1324, 1325, 5, 5, 0, 0, 1325, 1327, 3, 64, 32, 0, 1326, 1324,
1, 0, 0, 0, 1327, 1330, 1, 0, 0, 0, 1328, 1326, 1, 0, 0, 0, 1328, 1329,
1, 0, 0, 0, 1329, 1333, 1, 0, 0, 0, 1330, 1328, 1, 0, 0, 0, 1331, 1332,
5, 79, 0, 0, 1332, 1334, 3, 64, 32, 0, 1333, 1331, 1, 0, 0, 0, 1333, 1334,
1, 0, 0, 0, 1334, 1336, 1, 0, 0, 0, 1335, 1321, 1, 0, 0, 0, 1335, 1336,
1, 0, 0, 0, 1336, 1351, 1, 0, 0, 0, 1337, 1338, 5, 174, 0, 0, 1338, 1339,
3, 210, 105, 0, 1339, 1340, 5, 33, 0, 0, 1340, 1348, 3, 120, 60, 0, 1341,
1342, 5, 5, 0, 0, 1342, 1343, 3, 210, 105, 0, 1343, 1344, 5, 33, 0, 0,
1344, 1345, 3, 120, 60, 0, 1345, 1347, 1, 0, 0, 0, 1346, 1341, 1, 0, 0,
0, 1347, 1350, 1, 0, 0, 0, 1348, 1346, 1, 0, 0, 0, 1348, 1349, 1, 0, 0,
0, 1349, 1352, 1, 0, 0, 0, 1350, 1348, 1, 0, 0, 0, 1351, 1337, 1, 0, 0,
0, 1351, 1352, 1, 0, 0, 0, 1352, 1382, 1, 0, 0, 0, 1353, 1354, 5, 144,
0, 0, 1354, 1355, 5, 3, 0, 0, 1355, 1360, 3, 64, 32, 0, 1356, 1357, 5,
5, 0, 0, 1357, 1359, 3, 64, 32, 0, 1358, 1356, 1, 0, 0, 0, 1359, 1362,
1, 0, 0, 0, 1360, 1358, 1, 0, 0, 0, 1360, 1361, 1, 0, 0, 0, 1361, 1363,
1, 0, 0, 0, 1362, 1360, 1, 0, 0, 0, 1363, 1378, 5, 4, 0, 0, 1364, 1365,
5, 5, 0, 0, 1365, 1366, 5, 3, 0, 0, 1366, 1371, 3, 64, 32, 0, 1367, 1368,
5, 5, 0, 0, 1368, 1370, 3, 64, 32, 0, 1369, 1367, 1, 0, 0, 0, 1370, 1373,
1, 0, 0, 0, 1371, 1369, 1, 0, 0, 0, 1371, 1372, 1, 0, 0, 0, 1372, 1374,
1, 0, 0, 0, 1373, 1371, 1, 0, 0, 0, 1374, 1375, 5, 4, 0, 0, 1375, 1377,
1, 0, 0, 0, 1376, 1364, 1, 0, 0, 0, 1377, 1380, 1, 0, 0, 0, 1378, 1376,
1, 0, 0, 0, 1378, 1379, 1, 0, 0, 0, 1379, 1382, 1, 0, 0, 0, 1380, 1378,
1, 0, 0, 0, 1381, 1291, 1, 0, 0, 0, 1381, 1353, 1, 0, 0, 0, 1382, 87, 1,
0, 0, 0, 1383, 1384, 3, 82, 41, 0, 1384, 89, 1, 0, 0, 0, 1385, 1387, 3,
134, 67, 0, 1386, 1385, 1, 0, 0, 0, 1386, 1387, 1, 0, 0, 0, 1387, 1388,
1, 0, 0, 0, 1388, 1390, 3, 86, 43, 0, 1389, 1391, 3, 136, 68, 0, 1390,
1389, 1, 0, 0, 0, 1390, 1391, 1, 0, 0, 0, 1391, 1393, 1, 0, 0, 0, 1392,
1394, 3, 138, 69, 0, 1393, 1392, 1, 0, 0, 0, 1393, 1394, 1, 0, 0, 0, 1394,
91, 1, 0, 0, 0, 1395, 1397, 3, 134, 67, 0, 1396, 1395, 1, 0, 0, 0, 1396,
1397, 1, 0, 0, 0, 1397, 1398, 1, 0, 0, 0, 1398, 1408, 3, 86, 43, 0, 1399,
1401, 5, 139, 0, 0, 1400, 1402, 5, 29, 0, 0, 1401, 1400, 1, 0, 0, 0, 1401,
1402, 1, 0, 0, 0, 1402, 1406, 1, 0, 0, 0, 1403, 1406, 5, 90, 0, 0, 1404,
1406, 5, 68, 0, 0, 1405, 1399, 1, 0, 0, 0, 1405, 1403, 1, 0, 0, 0, 1405,
1404, 1, 0, 0, 0, 1406, 1407, 1, 0, 0, 0, 1407, 1409, 3, 86, 43, 0, 1408,
1405, 1, 0, 0, 0, 1409, 1410, 1, 0, 0, 0, 1410, 1408, 1, 0, 0, 0, 1410,
1411, 1, 0, 0, 0, 1411, 1413, 1, 0, 0, 0, 1412, 1414, 3, 136, 68, 0, 1413,
1412, 1, 0, 0, 0, 1413, 1414, 1, 0, 0, 0, 1414, 1416, 1, 0, 0, 0, 1415,
1417, 3, 138, 69, 0, 1416, 1415, 1, 0, 0, 0, 1416, 1417, 1, 0, 0, 0, 1417,
93, 1, 0, 0, 0, 1418, 1419, 3, 182, 91, 0, 1419, 1420, 5, 2, 0, 0, 1420,
1422, 1, 0, 0, 0, 1421, 1418, 1, 0, 0, 0, 1421, 1422, 1, 0, 0, 0, 1422,
1423, 1, 0, 0, 0, 1423, 1428, 3, 184, 92, 0, 1424, 1426, 5, 33, 0, 0, 1425,
1424, 1, 0, 0, 0, 1425, 1426, 1, 0, 0, 0, 1426, 1427, 1, 0, 0, 0, 1427,
1429, 3, 206, 103, 0, 1428, 1425, 1, 0, 0, 0, 1428, 1429, 1, 0, 0, 0, 1429,
1435, 1, 0, 0, 0, 1430, 1431, 5, 85, 0, 0, 1431, 1432, 5, 40, 0, 0, 1432,
1436, 3, 194, 97, 0, 1433, 1434, 5, 102, 0, 0, 1434, 1436, 5, 85, 0, 0,
1435, 1430, 1, 0, 0, 0, 1435, 1433, 1, 0, 0, 0, 1435, 1436, 1, 0, 0, 0,
1436, 1483, 1, 0, 0, 0, 1437, 1438, 3, 182, 91, 0, 1438, 1439, 5, 2, 0,
0, 1439, 1441, 1, 0, 0, 0, 1440, 1437, 1, 0, 0, 0, 1440, 1441, 1, 0, 0,
0, 1441, 1442, 1, 0, 0, 0, 1442, 1443, 3, 222, 111, 0, 1443, 1444, 5, 3,
0, 0, 1444, 1449, 3, 64, 32, 0, 1445, 1446, 5, 5, 0, 0, 1446, 1448, 3,
64, 32, 0, 1447, 1445, 1, 0, 0, 0, 1448, 1451, 1, 0, 0, 0, 1449, 1447,
1, 0, 0, 0, 1449, 1450, 1, 0, 0, 0, 1450, 1452, 1, 0, 0, 0, 1451, 1449,
1, 0, 0, 0, 1452, 1457, 5, 4, 0, 0, 1453, 1455, 5, 33, 0, 0, 1454, 1453,
1, 0, 0, 0, 1454, 1455, 1, 0, 0, 0, 1455, 1456, 1, 0, 0, 0, 1456, 1458,
3, 206, 103, 0, 1457, 1454, 1, 0, 0, 0, 1457, 1458, 1, 0, 0, 0, 1458, 1483,
1, 0, 0, 0, 1459, 1469, 5, 3, 0, 0, 1460, 1465, 3, 94, 47, 0, 1461, 1462,
5, 5, 0, 0, 1462, 1464, 3, 94, 47, 0, 1463, 1461, 1, 0, 0, 0, 1464, 1467,
1, 0, 0, 0, 1465, 1463, 1, 0, 0, 0, 1465, 1466, 1, 0, 0, 0, 1466, 1470,
1, 0, 0, 0, 1467, 1465, 1, 0, 0, 0, 1468, 1470, 3, 84, 42, 0, 1469, 1460,
1, 0, 0, 0, 1469, 1468, 1, 0, 0, 0, 1470, 1471, 1, 0, 0, 0, 1471, 1472,
5, 4, 0, 0, 1472, 1483, 1, 0, 0, 0, 1473, 1474, 5, 3, 0, 0, 1474, 1475,
3, 82, 41, 0, 1475, 1480, 5, 4, 0, 0, 1476, 1478, 5, 33, 0, 0, 1477, 1476,
1, 0, 0, 0, 1477, 1478, 1, 0, 0, 0, 1478, 1479, 1, 0, 0, 0, 1479, 1481,
3, 206, 103, 0, 1480, 1477, 1, 0, 0, 0, 1480, 1481, 1, 0, 0, 0, 1481, 1483,
1, 0, 0, 0, 1482, 1421, 1, 0, 0, 0, 1482, 1440, 1, 0, 0, 0, 1482, 1459,
1, 0, 0, 0, 1482, 1473, 1, 0, 0, 0, 1483, 95, 1, 0, 0, 0, 1484, 1497, 5,
7, 0, 0, 1485, 1486, 3, 184, 92, 0, 1486, 1487, 5, 2, 0, 0, 1487, 1488,
5, 7, 0, 0, 1488, 1497, 1, 0, 0, 0, 1489, 1494, 3, 64, 32, 0, 1490, 1492,
5, 33, 0, 0, 1491, 1490, 1, 0, 0, 0, 1491, 1492, 1, 0, 0, 0, 1492, 1493,
1, 0, 0, 0, 1493, 1495, 3, 174, 87, 0, 1494, 1491, 1, 0, 0, 0, 1494, 1495,
1, 0, 0, 0, 1495, 1497, 1, 0, 0, 0, 1496, 1484, 1, 0, 0, 0, 1496, 1485,
1, 0, 0, 0, 1496, 1489, 1, 0, 0, 0, 1497, 97, 1, 0, 0, 0, 1498, 1512, 5,
5, 0, 0, 1499, 1501, 5, 100, 0, 0, 1500, 1499, 1, 0, 0, 0, 1500, 1501,
1, 0, 0, 0, 1501, 1508, 1, 0, 0, 0, 1502, 1504, 5, 96, 0, 0, 1503, 1505,
5, 110, 0, 0, 1504, 1503, 1, 0, 0, 0, 1504, 1505, 1, 0, 0, 0, 1505, 1509,
1, 0, 0, 0, 1506, 1509, 5, 87, 0, 0, 1507, 1509, 5, 51, 0, 0, 1508, 1502,
1, 0, 0, 0, 1508, 1506, 1, 0, 0, 0, 1508, 1507, 1, 0, 0, 0, 1508, 1509,
1, 0, 0, 0, 1509, 1510, 1, 0, 0, 0, 1510, 1512, 5, 94, 0, 0, 1511, 1498,
1, 0, 0, 0, 1511, 1500, 1, 0, 0, 0, 1512, 99, 1, 0, 0, 0, 1513, 1514, 5,
107, 0, 0, 1514, 1528, 3, 64, 32, 0, 1515, 1516, 5, 142, 0, 0, 1516, 1517,
5, 3, 0, 0, 1517, 1522, 3, 188, 94, 0, 1518, 1519, 5, 5, 0, 0, 1519, 1521,
3, 188, 94, 0, 1520, 1518, 1, 0, 0, 0, 1521, 1524, 1, 0, 0, 0, 1522, 1520,
1, 0, 0, 0, 1522, 1523, 1, 0, 0, 0, 1523, 1525, 1, 0, 0, 0, 1524, 1522,
1, 0, 0, 0, 1525, 1526, 5, 4, 0, 0, 1526, 1528, 1, 0, 0, 0, 1527, 1513,
1, 0, 0, 0, 1527, 1515, 1, 0, 0, 0, 1528, 101, 1, 0, 0, 0, 1529, 1531,
5, 139, 0, 0, 1530, 1532, 5, 29, 0, 0, 1531, 1530, 1, 0, 0, 0, 1531, 1532,
1, 0, 0, 0, 1532, 1536, 1, 0, 0, 0, 1533, 1536, 5, 90, 0, 0, 1534, 1536,
5, 68, 0, 0, 1535, 1529, 1, 0, 0, 0, 1535, 1533, 1, 0, 0, 0, 1535, 1534,
1, 0, 0, 0, 1536, 103, 1, 0, 0, 0, 1537, 1539, 3, 48, 24, 0, 1538, 1537,
1, 0, 0, 0, 1538, 1539, 1, 0, 0, 0, 1539, 1540, 1, 0, 0, 0, 1540, 1543,
5, 141, 0, 0, 1541, 1542, 5, 108, 0, 0, 1542, 1544, 7, 8, 0, 0, 1543, 1541,
1, 0, 0, 0, 1543, 1544, 1, 0, 0, 0, 1544, 1545, 1, 0, 0, 0, 1545, 1546,
3, 114, 57, 0, 1546, 1547, 5, 131, 0, 0, 1547, 1560, 3, 106, 53, 0, 1548,
1558, 5, 75, 0, 0, 1549, 1554, 3, 94, 47, 0, 1550, 1551, 5, 5, 0, 0, 1551,
1553, 3, 94, 47, 0, 1552, 1550, 1, 0, 0, 0, 1553, 1556, 1, 0, 0, 0, 1554,
1552, 1, 0, 0, 0, 1554, 1555, 1, 0, 0, 0, 1555, 1559, 1, 0, 0, 0, 1556,
1554, 1, 0, 0, 0, 1557, 1559, 3, 84, 42, 0, 1558, 1549, 1, 0, 0, 0, 1558,
1557, 1, 0, 0, 0, 1559, 1561, 1, 0, 0, 0, 1560, 1548, 1, 0, 0, 0, 1560,
1561, 1, 0, 0, 0, 1561, 1564, 1, 0, 0, 0, 1562, 1563, 5, 148, 0, 0, 1563,
1565, 3, 64, 32, 0, 1564, 1562, 1, 0, 0, 0, 1564, 1565, 1, 0, 0, 0, 1565,
1567, 1, 0, 0, 0, 1566, 1568, 3, 72, 36, 0, 1567, 1566, 1, 0, 0, 0, 1567,
1568, 1, 0, 0, 0, 1568, 105, 1, 0, 0, 0, 1569, 1574, 3, 108, 54, 0, 1570,
1571, 5, 5, 0, 0, 1571, 1573, 3, 108, 54, 0, 1572, 1570, 1, 0, 0, 0, 1573,
1576, 1, 0, 0, 0, 1574, 1572, 1, 0, 0, 0, 1574, 1575, 1, 0, 0, 0, 1575,
107, 1, 0, 0, 0, 1576, 1574, 1, 0, 0, 0, 1577, 1580, 3, 188, 94, 0, 1578,
1580, 3, 110, 55, 0, 1579, 1577, 1, 0, 0, 0, 1579, 1578, 1, 0, 0, 0, 1580,
1581, 1, 0, 0, 0, 1581, 1582, 5, 6, 0, 0, 1582, 1583, 3, 64, 32, 0, 1583,
109, 1, 0, 0, 0, 1584, 1585, 5, 3, 0, 0, 1585, 1590, 3, 188, 94, 0, 1586,
1587, 5, 5, 0, 0, 1587, 1589, 3, 188, 94, 0, 1588, 1586, 1, 0, 0, 0, 1589,
1592, 1, 0, 0, 0, 1590, 1588, 1, 0, 0, 0, 1590, 1591, 1, 0, 0, 0, 1591,
1593, 1, 0, 0, 0, 1592, 1590, 1, 0, 0, 0, 1593, 1594, 5, 4, 0, 0, 1594,
111, 1, 0, 0, 0, 1595, 1597, 3, 48, 24, 0, 1596, 1595, 1, 0, 0, 0, 1596,
1597, 1, 0, 0, 0, 1597, 1598, 1, 0, 0, 0, 1598, 1601, 5, 141, 0, 0, 1599,
1600, 5, 108, 0, 0, 1600, 1602, 7, 8, 0, 0, 1601, 1599, 1, 0, 0, 0, 1601,
1602, 1, 0, 0, 0, 1602, 1603, 1, 0, 0, 0, 1603, 1604, 3, 114, 57, 0, 1604,
1607, 5, 131, 0, 0, 1605, 1608, 3, 188, 94, 0, 1606, 1608, 3, 110, 55,
0, 1607, 1605, 1, 0, 0, 0, 1607, 1606, 1, 0, 0, 0, 1608, 1609, 1, 0, 0,
0, 1609, 1610, 5, 6, 0, 0, 1610, 1621, 3, 64, 32, 0, 1611, 1614, 5, 5,
0, 0, 1612, 1615, 3, 188, 94, 0, 1613, 1615, 3, 110, 55, 0, 1614, 1612,
1, 0, 0, 0, 1614, 1613, 1, 0, 0, 0, 1615, 1616, 1, 0, 0, 0, 1616, 1617,
5, 6, 0, 0, 1617, 1618, 3, 64, 32, 0, 1618, 1620, 1, 0, 0, 0, 1619, 1611,
1, 0, 0, 0, 1620, 1623, 1, 0, 0, 0, 1621, 1619, 1, 0, 0, 0, 1621, 1622,
1, 0, 0, 0, 1622, 1626, 1, 0, 0, 0, 1623, 1621, 1, 0, 0, 0, 1624, 1625,
5, 148, 0, 0, 1625, 1627, 3, 64, 32, 0, 1626, 1624, 1, 0, 0, 0, 1626, 1627,
1, 0, 0, 0, 1627, 1629, 1, 0, 0, 0, 1628, 1630, 3, 72, 36, 0, 1629, 1628,
1, 0, 0, 0, 1629, 1630, 1, 0, 0, 0, 1630, 1635, 1, 0, 0, 0, 1631, 1633,
3, 136, 68, 0, 1632, 1631, 1, 0, 0, 0, 1632, 1633, 1, 0, 0, 0, 1633, 1634,
1, 0, 0, 0, 1634, 1636, 3, 138, 69, 0, 1635, 1632, 1, 0, 0, 0, 1635, 1636,
1, 0, 0, 0, 1636, 113, 1, 0, 0, 0, 1637, 1638, 3, 182, 91, 0, 1638, 1639,
5, 2, 0, 0, 1639, 1641, 1, 0, 0, 0, 1640, 1637, 1, 0, 0, 0, 1640, 1641,
1, 0, 0, 0, 1641, 1642, 1, 0, 0, 0, 1642, 1645, 3, 184, 92, 0, 1643, 1644,
5, 33, 0, 0, 1644, 1646, 3, 212, 106, 0, 1645, 1643, 1, 0, 0, 0, 1645,
1646, 1, 0, 0, 0, 1646, 1652, 1, 0, 0, 0, 1647, 1648, 5, 85, 0, 0, 1648,
1649, 5, 40, 0, 0, 1649, 1653, 3, 194, 97, 0, 1650, 1651, 5, 102, 0, 0,
1651, 1653, 5, 85, 0, 0, 1652, 1647, 1, 0, 0, 0, 1652, 1650, 1, 0, 0, 0,
1652, 1653, 1, 0, 0, 0, 1653, 115, 1, 0, 0, 0, 1654, 1656, 5, 143, 0, 0,
1655, 1657, 3, 182, 91, 0, 1656, 1655, 1, 0, 0, 0, 1656, 1657, 1, 0, 0,
0, 1657, 1660, 1, 0, 0, 0, 1658, 1659, 5, 91, 0, 0, 1659, 1661, 3, 214,
107, 0, 1660, 1658, 1, 0, 0, 0, 1660, 1661, 1, 0, 0, 0, 1661, 117, 1, 0,
0, 0, 1662, 1663, 5, 178, 0, 0, 1663, 1664, 5, 3, 0, 0, 1664, 1665, 5,
148, 0, 0, 1665, 1666, 3, 64, 32, 0, 1666, 1667, 5, 4, 0, 0, 1667, 119,
1, 0, 0, 0, 1668, 1670, 5, 3, 0, 0, 1669, 1671, 3, 216, 108, 0, 1670, 1669,
1, 0, 0, 0, 1670, 1671, 1, 0, 0, 0, 1671, 1682, 1, 0, 0, 0, 1672, 1673,
5, 153, 0, 0, 1673, 1674, 5, 40, 0, 0, 1674, 1679, 3, 64, 32, 0, 1675,
1676, 5, 5, 0, 0, 1676, 1678, 3, 64, 32, 0, 1677, 1675, 1, 0, 0, 0, 1678,
1681, 1, 0, 0, 0, 1679, 1677, 1, 0, 0, 0, 1679, 1680, 1, 0, 0, 0, 1680,
1683, 1, 0, 0, 0, 1681, 1679, 1, 0, 0, 0, 1682, 1672, 1, 0, 0, 0, 1682,
1683, 1, 0, 0, 0, 1683, 1684, 1, 0, 0, 0, 1684, 1685, 5, 109, 0, 0, 1685,
1686, 5, 40, 0, 0, 1686, 1691, 3, 140, 70, 0, 1687, 1688, 5, 5, 0, 0, 1688,
1690, 3, 140, 70, 0, 1689, 1687, 1, 0, 0, 0, 1690, 1693, 1, 0, 0, 0, 1691,
1689, 1, 0, 0, 0, 1691, 1692, 1, 0, 0, 0, 1692, 1695, 1, 0, 0, 0, 1693,
1691, 1, 0, 0, 0, 1694, 1696, 3, 124, 62, 0, 1695, 1694, 1, 0, 0, 0, 1695,
1696, 1, 0, 0, 0, 1696, 1697, 1, 0, 0, 0, 1697, 1698, 5, 4, 0, 0, 1698,
121, 1, 0, 0, 0, 1699, 1733, 5, 152, 0, 0, 1700, 1734, 3, 210, 105, 0,
1701, 1703, 5, 3, 0, 0, 1702, 1704, 3, 216, 108, 0, 1703, 1702, 1, 0, 0,
0, 1703, 1704, 1, 0, 0, 0, 1704, 1715, 1, 0, 0, 0, 1705, 1706, 5, 153,
0, 0, 1706, 1707, 5, 40, 0, 0, 1707, 1712, 3, 64, 32, 0, 1708, 1709, 5,
5, 0, 0, 1709, 1711, 3, 64, 32, 0, 1710, 1708, 1, 0, 0, 0, 1711, 1714,
1, 0, 0, 0, 1712, 1710, 1, 0, 0, 0, 1712, 1713, 1, 0, 0, 0, 1713, 1716,
1, 0, 0, 0, 1714, 1712, 1, 0, 0, 0, 1715, 1705, 1, 0, 0, 0, 1715, 1716,
1, 0, 0, 0, 1716, 1727, 1, 0, 0, 0, 1717, 1718, 5, 109, 0, 0, 1718, 1719,
5, 40, 0, 0, 1719, 1724, 3, 140, 70, 0, 1720, 1721, 5, 5, 0, 0, 1721, 1723,
3, 140, 70, 0, 1722, 1720, 1, 0, 0, 0, 1723, 1726, 1, 0, 0, 0, 1724, 1722,
1, 0, 0, 0, 1724, 1725, 1, 0, 0, 0, 1725, 1728, 1, 0, 0, 0, 1726, 1724,
1, 0, 0, 0, 1727, 1717, 1, 0, 0, 0, 1727, 1728, 1, 0, 0, 0, 1728, 1730,
1, 0, 0, 0, 1729, 1731, 3, 124, 62, 0, 1730, 1729, 1, 0, 0, 0, 1730, 1731,
1, 0, 0, 0, 1731, 1732, 1, 0, 0, 0, 1732, 1734, 5, 4, 0, 0, 1733, 1700,
1, 0, 0, 0, 1733, 1701, 1, 0, 0, 0, 1734, 123, 1, 0, 0, 0, 1735, 1743,
3, 126, 63, 0, 1736, 1737, 5, 180, 0, 0, 1737, 1738, 5, 101, 0, 0, 1738,
1744, 5, 182, 0, 0, 1739, 1740, 5, 157, 0, 0, 1740, 1744, 5, 127, 0, 0,
1741, 1744, 5, 78, 0, 0, 1742, 1744, 5, 181, 0, 0, 1743, 1736, 1, 0, 0,
0, 1743, 1739, 1, 0, 0, 0, 1743, 1741, 1, 0, 0, 0, 1743, 1742, 1, 0, 0,
0, 1743, 1744, 1, 0, 0, 0, 1744, 125, 1, 0, 0, 0, 1745, 1752, 7, 17, 0,
0, 1746, 1753, 3, 148, 74, 0, 1747, 1748, 5, 39, 0, 0, 1748, 1749, 3, 144,
72, 0, 1749, 1750, 5, 32, 0, 0, 1750, 1751, 3, 146, 73, 0, 1751, 1753,
1, 0, 0, 0, 1752, 1746, 1, 0, 0, 0, 1752, 1747, 1, 0, 0, 0, 1753, 127,
1, 0, 0, 0, 1754, 1755, 3, 218, 109, 0, 1755, 1765, 5, 3, 0, 0, 1756, 1761,
3, 64, 32, 0, 1757, 1758, 5, 5, 0, 0, 1758, 1760, 3, 64, 32, 0, 1759, 1757,
1, 0, 0, 0, 1760, 1763, 1, 0, 0, 0, 1761, 1759, 1, 0, 0, 0, 1761, 1762,
1, 0, 0, 0, 1762, 1766, 1, 0, 0, 0, 1763, 1761, 1, 0, 0, 0, 1764, 1766,
5, 7, 0, 0, 1765, 1756, 1, 0, 0, 0, 1765, 1764, 1, 0, 0, 0, 1766, 1767,
1, 0, 0, 0, 1767, 1768, 5, 4, 0, 0, 1768, 129, 1, 0, 0, 0, 1769, 1770,
3, 220, 110, 0, 1770, 1783, 5, 3, 0, 0, 1771, 1773, 5, 62, 0, 0, 1772,
1771, 1, 0, 0, 0, 1772, 1773, 1, 0, 0, 0, 1773, 1774, 1, 0, 0, 0, 1774,
1779, 3, 64, 32, 0, 1775, 1776, 5, 5, 0, 0, 1776, 1778, 3, 64, 32, 0, 1777,
1775, 1, 0, 0, 0, 1778, 1781, 1, 0, 0, 0, 1779, 1777, 1, 0, 0, 0, 1779,
1780, 1, 0, 0, 0, 1780, 1784, 1, 0, 0, 0, 1781, 1779, 1, 0, 0, 0, 1782,
1784, 5, 7, 0, 0, 1783, 1772, 1, 0, 0, 0, 1783, 1782, 1, 0, 0, 0, 1783,
1784, 1, 0, 0, 0, 1784, 1785, 1, 0, 0, 0, 1785, 1787, 5, 4, 0, 0, 1786,
1788, 3, 118, 59, 0, 1787, 1786, 1, 0, 0, 0, 1787, 1788, 1, 0, 0, 0, 1788,
131, 1, 0, 0, 0, 1789, 1790, 3, 150, 75, 0, 1790, 1800, 5, 3, 0, 0, 1791,
1796, 3, 64, 32, 0, 1792, 1793, 5, 5, 0, 0, 1793, 1795, 3, 64, 32, 0, 1794,
1792, 1, 0, 0, 0, 1795, 1798, 1, 0, 0, 0, 1796, 1794, 1, 0, 0, 0, 1796,
1797, 1, 0, 0, 0, 1797, 1801, 1, 0, 0, 0, 1798, 1796, 1, 0, 0, 0, 1799,
1801, 5, 7, 0, 0, 1800, 1791, 1, 0, 0, 0, 1800, 1799, 1, 0, 0, 0, 1800,
1801, 1, 0, 0, 0, 1801, 1802, 1, 0, 0, 0, 1802, 1804, 5, 4, 0, 0, 1803,
1805, 3, 118, 59, 0, 1804, 1803, 1, 0, 0, 0, 1804, 1805, 1, 0, 0, 0, 1805,
1806, 1, 0, 0, 0, 1806, 1809, 5, 152, 0, 0, 1807, 1810, 3, 120, 60, 0,
1808, 1810, 3, 210, 105, 0, 1809, 1807, 1, 0, 0, 0, 1809, 1808, 1, 0, 0,
0, 1810, 133, 1, 0, 0, 0, 1811, 1813, 5, 149, 0, 0, 1812, 1814, 5, 116,
0, 0, 1813, 1812, 1, 0, 0, 0, 1813, 1814, 1, 0, 0, 0, 1814, 1815, 1, 0,
0, 0, 1815, 1820, 3, 54, 27, 0, 1816, 1817, 5, 5, 0, 0, 1817, 1819, 3,
54, 27, 0, 1818, 1816, 1, 0, 0, 0, 1819, 1822, 1, 0, 0, 0, 1820, 1818,
1, 0, 0, 0, 1820, 1821, 1, 0, 0, 0, 1821, 135, 1, 0, 0, 0, 1822, 1820,
1, 0, 0, 0, 1823, 1824, 5, 109, 0, 0, 1824, 1825, 5, 40, 0, 0, 1825, 1830,
3, 140, 70, 0, 1826, 1827, 5, 5, 0, 0, 1827, 1829, 3, 140, 70, 0, 1828,
1826, 1, 0, 0, 0, 1829, 1832, 1, 0, 0, 0, 1830, 1828, 1, 0, 0, 0, 1830,
1831, 1, 0, 0, 0, 1831, 137, 1, 0, 0, 0, 1832, 1830, 1, 0, 0, 0, 1833,
1834, 5, 98, 0, 0, 1834, 1837, 3, 64, 32, 0, 1835, 1836, 7, 18, 0, 0, 1836,
1838, 3, 64, 32, 0, 1837, 1835, 1, 0, 0, 0, 1837, 1838, 1, 0, 0, 0, 1838,
139, 1, 0, 0, 0, 1839, 1842, 3, 64, 32, 0, 1840, 1841, 5, 45, 0, 0, 1841,
1843, 3, 190, 95, 0, 1842, 1840, 1, 0, 0, 0, 1842, 1843, 1, 0, 0, 0, 1843,
1845, 1, 0, 0, 0, 1844, 1846, 3, 142, 71, 0, 1845, 1844, 1, 0, 0, 0, 1845,
1846, 1, 0, 0, 0, 1846, 1849, 1, 0, 0, 0, 1847, 1848, 5, 175, 0, 0, 1848,
1850, 7, 19, 0, 0, 1849, 1847, 1, 0, 0, 0, 1849, 1850, 1, 0, 0, 0, 1850,
141, 1, 0, 0, 0, 1851, 1852, 7, 20, 0, 0, 1852, 143, 1, 0, 0, 0, 1853,
1854, 3, 64, 32, 0, 1854, 1855, 5, 155, 0, 0, 1855, 1864, 1, 0, 0, 0, 1856,
1857, 3, 64, 32, 0, 1857, 1858, 5, 158, 0, 0, 1858, 1864, 1, 0, 0, 0, 1859,
1860, 5, 157, 0, 0, 1860, 1864, 5, 127, 0, 0, 1861, 1862, 5, 156, 0, 0,
1862, 1864, 5, 155, 0, 0, 1863, 1853, 1, 0, 0, 0, 1863, 1856, 1, 0, 0,
0, 1863, 1859, 1, 0, 0, 0, 1863, 1861, 1, 0, 0, 0, 1864, 145, 1, 0, 0,
0, 1865, 1866, 3, 64, 32, 0, 1866, 1867, 5, 155, 0, 0, 1867, 1876, 1, 0,
0, 0, 1868, 1869, 3, 64, 32, 0, 1869, 1870, 5, 158, 0, 0, 1870, 1876, 1,
0, 0, 0, 1871, 1872, 5, 157, 0, 0, 1872, 1876, 5, 127, 0, 0, 1873, 1874,
5, 156, 0, 0, 1874, 1876, 5, 158, 0, 0, 1875, 1865, 1, 0, 0, 0, 1875, 1868,
1, 0, 0, 0, 1875, 1871, 1, 0, 0, 0, 1875, 1873, 1, 0, 0, 0, 1876, 147,
1, 0, 0, 0, 1877, 1878, 3, 64, 32, 0, 1878, 1879, 5, 155, 0, 0, 1879, 1885,
1, 0, 0, 0, 1880, 1881, 5, 156, 0, 0, 1881, 1885, 5, 155, 0, 0, 1882, 1883,
5, 157, 0, 0, 1883, 1885, 5, 127, 0, 0, 1884, 1877, 1, 0, 0, 0, 1884, 1880,
1, 0, 0, 0, 1884, 1882, 1, 0, 0, 0, 1885, 149, 1, 0, 0, 0, 1886, 1887,
7, 21, 0, 0, 1887, 1888, 5, 3, 0, 0, 1888, 1889, 3, 64, 32, 0, 1889, 1890,
5, 4, 0, 0, 1890, 1891, 5, 152, 0, 0, 1891, 1893, 5, 3, 0, 0, 1892, 1894,
3, 156, 78, 0, 1893, 1892, 1, 0, 0, 0, 1893, 1894, 1, 0, 0, 0, 1894, 1895,
1, 0, 0, 0, 1895, 1897, 3, 160, 80, 0, 1896, 1898, 3, 126, 63, 0, 1897,
1896, 1, 0, 0, 0, 1897, 1898, 1, 0, 0, 0, 1898, 1899, 1, 0, 0, 0, 1899,
1900, 5, 4, 0, 0, 1900, 1972, 1, 0, 0, 0, 1901, 1902, 7, 22, 0, 0, 1902,
1903, 5, 3, 0, 0, 1903, 1904, 5, 4, 0, 0, 1904, 1905, 5, 152, 0, 0, 1905,
1907, 5, 3, 0, 0, 1906, 1908, 3, 156, 78, 0, 1907, 1906, 1, 0, 0, 0, 1907,
1908, 1, 0, 0, 0, 1908, 1910, 1, 0, 0, 0, 1909, 1911, 3, 158, 79, 0, 1910,
1909, 1, 0, 0, 0, 1910, 1911, 1, 0, 0, 0, 1911, 1912, 1, 0, 0, 0, 1912,
1972, 5, 4, 0, 0, 1913, 1914, 7, 23, 0, 0, 1914, 1915, 5, 3, 0, 0, 1915,
1916, 5, 4, 0, 0, 1916, 1917, 5, 152, 0, 0, 1917, 1919, 5, 3, 0, 0, 1918,
1920, 3, 156, 78, 0, 1919, 1918, 1, 0, 0, 0, 1919, 1920, 1, 0, 0, 0, 1920,
1921, 1, 0, 0, 0, 1921, 1922, 3, 160, 80, 0, 1922, 1923, 5, 4, 0, 0, 1923,
1972, 1, 0, 0, 0, 1924, 1925, 7, 24, 0, 0, 1925, 1926, 5, 3, 0, 0, 1926,
1928, 3, 64, 32, 0, 1927, 1929, 3, 152, 76, 0, 1928, 1927, 1, 0, 0, 0,
1928, 1929, 1, 0, 0, 0, 1929, 1931, 1, 0, 0, 0, 1930, 1932, 3, 154, 77,
0, 1931, 1930, 1, 0, 0, 0, 1931, 1932, 1, 0, 0, 0, 1932, 1933, 1, 0, 0,
0, 1933, 1934, 5, 4, 0, 0, 1934, 1935, 5, 152, 0, 0, 1935, 1937, 5, 3,
0, 0, 1936, 1938, 3, 156, 78, 0, 1937, 1936, 1, 0, 0, 0, 1937, 1938, 1,
0, 0, 0, 1938, 1939, 1, 0, 0, 0, 1939, 1940, 3, 160, 80, 0, 1940, 1941,
5, 4, 0, 0, 1941, 1972, 1, 0, 0, 0, 1942, 1943, 5, 164, 0, 0, 1943, 1944,
5, 3, 0, 0, 1944, 1945, 3, 64, 32, 0, 1945, 1946, 5, 5, 0, 0, 1946, 1947,
3, 34, 17, 0, 1947, 1948, 5, 4, 0, 0, 1948, 1949, 5, 152, 0, 0, 1949, 1951,
5, 3, 0, 0, 1950, 1952, 3, 156, 78, 0, 1951, 1950, 1, 0, 0, 0, 1951, 1952,
1, 0, 0, 0, 1952, 1953, 1, 0, 0, 0, 1953, 1955, 3, 160, 80, 0, 1954, 1956,
3, 126, 63, 0, 1955, 1954, 1, 0, 0, 0, 1955, 1956, 1, 0, 0, 0, 1956, 1957,
1, 0, 0, 0, 1957, 1958, 5, 4, 0, 0, 1958, 1972, 1, 0, 0, 0, 1959, 1960,
5, 165, 0, 0, 1960, 1961, 5, 3, 0, 0, 1961, 1962, 3, 64, 32, 0, 1962, 1963,
5, 4, 0, 0, 1963, 1964, 5, 152, 0, 0, 1964, 1966, 5, 3, 0, 0, 1965, 1967,
3, 156, 78, 0, 1966, 1965, 1, 0, 0, 0, 1966, 1967, 1, 0, 0, 0, 1967, 1968,
1, 0, 0, 0, 1968, 1969, 3, 160, 80, 0, 1969, 1970, 5, 4, 0, 0, 1970, 1972,
1, 0, 0, 0, 1971, 1886, 1, 0, 0, 0, 1971, 1901, 1, 0, 0, 0, 1971, 1913,
1, 0, 0, 0, 1971, 1924, 1, 0, 0, 0, 1971, 1942, 1, 0, 0, 0, 1971, 1959,
1, 0, 0, 0, 1972, 151, 1, 0, 0, 0, 1973, 1974, 5, 5, 0, 0, 1974, 1975,
3, 34, 17, 0, 1975, 153, 1, 0, 0, 0, 1976, 1977, 5, 5, 0, 0, 1977, 1978,
3, 34, 17, 0, 1978, 155, 1, 0, 0, 0, 1979, 1980, 5, 153, 0, 0, 1980, 1982,
5, 40, 0, 0, 1981, 1983, 3, 64, 32, 0, 1982, 1981, 1, 0, 0, 0, 1983, 1984,
1, 0, 0, 0, 1984, 1982, 1, 0, 0, 0, 1984, 1985, 1, 0, 0, 0, 1985, 157,
1, 0, 0, 0, 1986, 1987, 5, 109, 0, 0, 1987, 1989, 5, 40, 0, 0, 1988, 1990,
3, 64, 32, 0, 1989, 1988, 1, 0, 0, 0, 1990, 1991, 1, 0, 0, 0, 1991, 1989,
1, 0, 0, 0, 1991, 1992, 1, 0, 0, 0, 1992, 159, 1, 0, 0, 0, 1993, 1994,
5, 109, 0, 0, 1994, 1995, 5, 40, 0, 0, 1995, 1996, 3, 162, 81, 0, 1996,
161, 1, 0, 0, 0, 1997, 1999, 3, 64, 32, 0, 1998, 2000, 3, 142, 71, 0, 1999,
1998, 1, 0, 0, 0, 1999, 2000, 1, 0, 0, 0, 2000, 2008, 1, 0, 0, 0, 2001,
2002, 5, 5, 0, 0, 2002, 2004, 3, 64, 32, 0, 2003, 2005, 3, 142, 71, 0,
2004, 2003, 1, 0, 0, 0, 2004, 2005, 1, 0, 0, 0, 2005, 2007, 1, 0, 0, 0,
2006, 2001, 1, 0, 0, 0, 2007, 2010, 1, 0, 0, 0, 2008, 2006, 1, 0, 0, 0,
2008, 2009, 1, 0, 0, 0, 2009, 163, 1, 0, 0, 0, 2010, 2008, 1, 0, 0, 0,
2011, 2012, 3, 82, 41, 0, 2012, 165, 1, 0, 0, 0, 2013, 2014, 3, 82, 41,
0, 2014, 167, 1, 0, 0, 0, 2015, 2016, 7, 25, 0, 0, 2016, 169, 1, 0, 0,
0, 2017, 2018, 5, 188, 0, 0, 2018, 171, 1, 0, 0, 0, 2019, 2022, 3, 64,
32, 0, 2020, 2022, 3, 28, 14, 0, 2021, 2019, 1, 0, 0, 0, 2021, 2020, 1,
0, 0, 0, 2022, 173, 1, 0, 0, 0, 2023, 2024, 7, 26, 0, 0, 2024, 175, 1,
0, 0, 0, 2025, 2026, 7, 27, 0, 0, 2026, 177, 1, 0, 0, 0, 2027, 2028, 3,
224, 112, 0, 2028, 179, 1, 0, 0, 0, 2029, 2030, 3, 224, 112, 0, 2030, 181,
1, 0, 0, 0, 2031, 2032, 3, 224, 112, 0, 2032, 183, 1, 0, 0, 0, 2033, 2034,
3, 224, 112, 0, 2034, 185, 1, 0, 0, 0, 2035, 2036, 3, 224, 112, 0, 2036,
187, 1, 0, 0, 0, 2037, 2038, 3, 224, 112, 0, 2038, 189, 1, 0, 0, 0, 2039,
2040, 3, 224, 112, 0, 2040, 191, 1, 0, 0, 0, 2041, 2042, 3, 224, 112, 0,
2042, 193, 1, 0, 0, 0, 2043, 2044, 3, 224, 112, 0, 2044, 195, 1, 0, 0,
0, 2045, 2046, 3, 224, 112, 0, 2046, 197, 1, 0, 0, 0, 2047, 2048, 3, 224,
112, 0, 2048, 199, 1, 0, 0, 0, 2049, 2050, 3, 224, 112, 0, 2050, 201, 1,
0, 0, 0, 2051, 2052, 3, 224, 112, 0, 2052, 203, 1, 0, 0, 0, 2053, 2054,
3, 224, 112, 0, 2054, 205, 1, 0, 0, 0, 2055, 2056, 3, 224, 112, 0, 2056,
207, 1, 0, 0, 0, 2057, 2058, 3, 224, 112, 0, 2058, 209, 1, 0, 0, 0, 2059,
2060, 3, 224, 112, 0, 2060, 211, 1, 0, 0, 0, 2061, 2062, 3, 224, 112, 0,
2062, 213, 1, 0, 0, 0, 2063, 2064, 3, 224, 112, 0, 2064, 215, 1, 0, 0,
0, 2065, 2066, 3, 224, 112, 0, 2066, 217, 1, 0, 0, 0, 2067, 2068, 3, 224,
112, 0, 2068, 219, 1, 0, 0, 0, 2069, 2070, 3, 224, 112, 0, 2070, 221, 1,
0, 0, 0, 2071, 2072, 3, 224, 112, 0, 2072, 223, 1, 0, 0, 0, 2073, 2081,
5, 185, 0, 0, 2074, 2081, 3, 176, 88, 0, 2075, 2081, 5, 188, 0, 0, 2076,
2077, 5, 3, 0, 0, 2077, 2078, 3, 224, 112, 0, 2078, 2079, 5, 4, 0, 0, 2079,
2081, 1, 0, 0, 0, 2080, 2073, 1, 0, 0, 0, 2080, 2074, 1, 0, 0, 0, 2080,
2075, 1, 0, 0, 0, 2080, 2076, 1, 0, 0, 0, 2081, 225, 1, 0, 0, 0, 297, 229,
237, 244, 249, 255, 261, 263, 289, 296, 303, 309, 313, 318, 321, 328, 331,
335, 343, 347, 349, 353, 357, 361, 364, 371, 377, 383, 388, 399, 405, 409,
413, 416, 420, 426, 431, 440, 447, 453, 457, 461, 466, 472, 484, 488, 493,
496, 499, 504, 507, 521, 528, 535, 537, 540, 546, 551, 559, 564, 579, 585,
595, 600, 610, 614, 616, 620, 625, 627, 635, 641, 646, 653, 664, 667, 669,
676, 680, 687, 693, 699, 705, 710, 719, 724, 735, 740, 751, 756, 760, 776,
786, 791, 799, 811, 816, 824, 831, 834, 837, 844, 847, 850, 853, 857, 865,
870, 880, 885, 894, 901, 905, 909, 912, 920, 933, 936, 944, 953, 957, 962,
992, 1004, 1009, 1021, 1027, 1034, 1038, 1048, 1051, 1057, 1063, 1072,
1075, 1079, 1081, 1083, 1092, 1099, 1106, 1112, 1117, 1125, 1130, 1139,
1150, 1157, 1161, 1164, 1168, 1171, 1179, 1190, 1196, 1198, 1206, 1213,
1220, 1225, 1227, 1233, 1242, 1247, 1254, 1258, 1260, 1263, 1271, 1275,
1278, 1284, 1288, 1293, 1300, 1309, 1313, 1315, 1319, 1328, 1333, 1335,
1348, 1351, 1360, 1371, 1378, 1381, 1386, 1390, 1393, 1396, 1401, 1405,
1410, 1413, 1416, 1421, 1425, 1428, 1435, 1440, 1449, 1454, 1457, 1465,
1469, 1477, 1480, 1482, 1491, 1494, 1496, 1500, 1504, 1508, 1511, 1522,
1527, 1531, 1535, 1538, 1543, 1554, 1558, 1560, 1564, 1567, 1574, 1579,
1590, 1596, 1601, 1607, 1614, 1621, 1626, 1629, 1632, 1635, 1640, 1645,
1652, 1656, 1660, 1670, 1679, 1682, 1691, 1695, 1703, 1712, 1715, 1724,
1727, 1730, 1733, 1743, 1752, 1761, 1765, 1772, 1779, 1783, 1787, 1796,
1800, 1804, 1809, 1813, 1820, 1830, 1837, 1842, 1845, 1849, 1863, 1875,
1884, 1893, 1897, 1907, 1910, 1919, 1928, 1931, 1937, 1951, 1955, 1966,
1971, 1984, 1991, 1999, 2004, 2008, 2021, 2080,
}
deserializer := antlr.NewATNDeserializer(nil)
staticData.atn = deserializer.Deserialize(staticData.serializedATN)
atn := staticData.atn
staticData.decisionToDFA = make([]*antlr.DFA, len(atn.DecisionToState))
decisionToDFA := staticData.decisionToDFA
for index, state := range atn.DecisionToState {
decisionToDFA[index] = antlr.NewDFA(state, index)
}
}
// ParserInit initializes any static state used to implement Parser. By default the
// static state used to implement the parser is lazily initialized during the first call to
// NewParser(). You can call this function if you wish to initialize the static state ahead
// of time.
func ParserInit() {
staticData := &parserParserStaticData
staticData.once.Do(parserParserInit)
}
// NewParser produces a new parser instance for the optional input antlr.TokenStream.
func NewParser(input antlr.TokenStream) *Parser {
ParserInit()
this := new(Parser)
this.BaseParser = antlr.NewBaseParser(input)
staticData := &parserParserStaticData
this.Interpreter = antlr.NewParserATNSimulator(this, staticData.atn, staticData.decisionToDFA, staticData.predictionContextCache)
this.RuleNames = staticData.ruleNames
this.LiteralNames = staticData.literalNames
this.SymbolicNames = staticData.symbolicNames
this.GrammarFileName = "Parser.g4"
return this
}
// Parser tokens.
const (
ParserEOF = antlr.TokenEOF
ParserSCOL = 1
ParserDOT = 2
ParserOPEN_PAR = 3
ParserCLOSE_PAR = 4
ParserCOMMA = 5
ParserASSIGN = 6
ParserSTAR = 7
ParserPLUS = 8
ParserMINUS = 9
ParserTILDE = 10
ParserPIPE2 = 11
ParserDIV = 12
ParserMOD = 13
ParserLT2 = 14
ParserGT2 = 15
ParserAMP = 16
ParserPIPE = 17
ParserLT = 18
ParserLT_EQ = 19
ParserGT = 20
ParserGT_EQ = 21
ParserEQ = 22
ParserNOT_EQ1 = 23
ParserNOT_EQ2 = 24
ParserABORT_ = 25
ParserACTION_ = 26
ParserADD_ = 27
ParserAFTER_ = 28
ParserALL_ = 29
ParserALTER_ = 30
ParserANALYZE_ = 31
ParserAND_ = 32
ParserAS_ = 33
ParserASC_ = 34
ParserATTACH_ = 35
ParserAUTOINCREMENT_ = 36
ParserBEFORE_ = 37
ParserBEGIN_ = 38
ParserBETWEEN_ = 39
ParserBY_ = 40
ParserCASCADE_ = 41
ParserCASE_ = 42
ParserCAST_ = 43
ParserCHECK_ = 44
ParserCOLLATE_ = 45
ParserCOLUMN_ = 46
ParserCOMMIT_ = 47
ParserCONFLICT_ = 48
ParserCONSTRAINT_ = 49
ParserCREATE_ = 50
ParserCROSS_ = 51
ParserCURRENT_DATE_ = 52
ParserCURRENT_TIME_ = 53
ParserCURRENT_TIMESTAMP_ = 54
ParserDATABASE_ = 55
ParserDEFAULT_ = 56
ParserDEFERRABLE_ = 57
ParserDEFERRED_ = 58
ParserDELETE_ = 59
ParserDESC_ = 60
ParserDETACH_ = 61
ParserDISTINCT_ = 62
ParserDROP_ = 63
ParserEACH_ = 64
ParserELSE_ = 65
ParserEND_ = 66
ParserESCAPE_ = 67
ParserEXCEPT_ = 68
ParserEXCLUSIVE_ = 69
ParserEXISTS_ = 70
ParserEXPLAIN_ = 71
ParserFAIL_ = 72
ParserFOR_ = 73
ParserFOREIGN_ = 74
ParserFROM_ = 75
ParserFULL_ = 76
ParserGLOB_ = 77
ParserGROUP_ = 78
ParserHAVING_ = 79
ParserIF_ = 80
ParserIGNORE_ = 81
ParserIMMEDIATE_ = 82
ParserIN_ = 83
ParserINDEX_ = 84
ParserINDEXED_ = 85
ParserINITIALLY_ = 86
ParserINNER_ = 87
ParserINSERT_ = 88
ParserINSTEAD_ = 89
ParserINTERSECT_ = 90
ParserINTO_ = 91
ParserIS_ = 92
ParserISNULL_ = 93
ParserJOIN_ = 94
ParserKEY_ = 95
ParserLEFT_ = 96
ParserLIKE_ = 97
ParserLIMIT_ = 98
ParserMATCH_ = 99
ParserNATURAL_ = 100
ParserNO_ = 101
ParserNOT_ = 102
ParserNOTNULL_ = 103
ParserNULL_ = 104
ParserOF_ = 105
ParserOFFSET_ = 106
ParserON_ = 107
ParserOR_ = 108
ParserORDER_ = 109
ParserOUTER_ = 110
ParserPLAN_ = 111
ParserPRAGMA_ = 112
ParserPRIMARY_ = 113
ParserQUERY_ = 114
ParserRAISE_ = 115
ParserRECURSIVE_ = 116
ParserREFERENCES_ = 117
ParserREGEXP_ = 118
ParserREINDEX_ = 119
ParserRELEASE_ = 120
ParserRENAME_ = 121
ParserREPLACE_ = 122
ParserRESTRICT_ = 123
ParserRETURNING_ = 124
ParserRIGHT_ = 125
ParserROLLBACK_ = 126
ParserROW_ = 127
ParserROWS_ = 128
ParserSAVEPOINT_ = 129
ParserSELECT_ = 130
ParserSET_ = 131
ParserTABLE_ = 132
ParserTEMP_ = 133
ParserTEMPORARY_ = 134
ParserTHEN_ = 135
ParserTO_ = 136
ParserTRANSACTION_ = 137
ParserTRIGGER_ = 138
ParserUNION_ = 139
ParserUNIQUE_ = 140
ParserUPDATE_ = 141
ParserUSING_ = 142
ParserVACUUM_ = 143
ParserVALUES_ = 144
ParserVIEW_ = 145
ParserVIRTUAL_ = 146
ParserWHEN_ = 147
ParserWHERE_ = 148
ParserWITH_ = 149
ParserWITHOUT_ = 150
ParserFIRST_VALUE_ = 151
ParserOVER_ = 152
ParserPARTITION_ = 153
ParserRANGE_ = 154
ParserPRECEDING_ = 155
ParserUNBOUNDED_ = 156
ParserCURRENT_ = 157
ParserFOLLOWING_ = 158
ParserCUME_DIST_ = 159
ParserDENSE_RANK_ = 160
ParserLAG_ = 161
ParserLAST_VALUE_ = 162
ParserLEAD_ = 163
ParserNTH_VALUE_ = 164
ParserNTILE_ = 165
ParserPERCENT_RANK_ = 166
ParserRANK_ = 167
ParserROW_NUMBER_ = 168
ParserGENERATED_ = 169
ParserALWAYS_ = 170
ParserSTORED_ = 171
ParserTRUE_ = 172
ParserFALSE_ = 173
ParserWINDOW_ = 174
ParserNULLS_ = 175
ParserFIRST_ = 176
ParserLAST_ = 177
ParserFILTER_ = 178
ParserGROUPS_ = 179
ParserEXCLUDE_ = 180
ParserTIES_ = 181
ParserOTHERS_ = 182
ParserDO_ = 183
ParserNOTHING_ = 184
ParserIDENTIFIER = 185
ParserNUMERIC_LITERAL = 186
ParserBIND_PARAMETER = 187
ParserSTRING_LITERAL = 188
ParserBLOB_LITERAL = 189
ParserSINGLE_LINE_COMMENT = 190
ParserMULTILINE_COMMENT = 191
ParserSPACES = 192
ParserUNEXPECTED_CHAR = 193
)
// Parser rules.
const (
ParserRULE_parse = 0
ParserRULE_sql_stmt_list = 1
ParserRULE_sql_stmt = 2
ParserRULE_alter_table_stmt = 3
ParserRULE_analyze_stmt = 4
ParserRULE_attach_stmt = 5
ParserRULE_begin_stmt = 6
ParserRULE_commit_stmt = 7
ParserRULE_rollback_stmt = 8
ParserRULE_savepoint_stmt = 9
ParserRULE_release_stmt = 10
ParserRULE_create_index_stmt = 11
ParserRULE_indexed_column = 12
ParserRULE_create_table_stmt = 13
ParserRULE_column_def = 14
ParserRULE_type_name = 15
ParserRULE_column_constraint = 16
ParserRULE_signed_number = 17
ParserRULE_table_constraint = 18
ParserRULE_foreign_key_clause = 19
ParserRULE_conflict_clause = 20
ParserRULE_create_trigger_stmt = 21
ParserRULE_create_view_stmt = 22
ParserRULE_create_virtual_table_stmt = 23
ParserRULE_with_clause = 24
ParserRULE_cte_table_name = 25
ParserRULE_recursive_cte = 26
ParserRULE_common_table_expression = 27
ParserRULE_delete_stmt = 28
ParserRULE_delete_stmt_limited = 29
ParserRULE_detach_stmt = 30
ParserRULE_drop_stmt = 31
ParserRULE_expr = 32
ParserRULE_raise_function = 33
ParserRULE_literal_value = 34
ParserRULE_insert_stmt = 35
ParserRULE_returning_clause = 36
ParserRULE_upsert_clause = 37
ParserRULE_pragma_stmt = 38
ParserRULE_pragma_value = 39
ParserRULE_reindex_stmt = 40
ParserRULE_select_stmt = 41
ParserRULE_join_clause = 42
ParserRULE_select_core = 43
ParserRULE_factored_select_stmt = 44
ParserRULE_simple_select_stmt = 45
ParserRULE_compound_select_stmt = 46
ParserRULE_table_or_subquery = 47
ParserRULE_result_column = 48
ParserRULE_join_operator = 49
ParserRULE_join_constraint = 50
ParserRULE_compound_operator = 51
ParserRULE_update_stmt = 52
ParserRULE_assignment_list = 53
ParserRULE_assignment = 54
ParserRULE_column_name_list = 55
ParserRULE_update_stmt_limited = 56
ParserRULE_qualified_table_name = 57
ParserRULE_vacuum_stmt = 58
ParserRULE_filter_clause = 59
ParserRULE_window_defn = 60
ParserRULE_over_clause = 61
ParserRULE_frame_spec = 62
ParserRULE_frame_clause = 63
ParserRULE_simple_function_invocation = 64
ParserRULE_aggregate_function_invocation = 65
ParserRULE_window_function_invocation = 66
ParserRULE_common_table_stmt = 67
ParserRULE_order_by_stmt = 68
ParserRULE_limit_stmt = 69
ParserRULE_ordering_term = 70
ParserRULE_asc_desc = 71
ParserRULE_frame_left = 72
ParserRULE_frame_right = 73
ParserRULE_frame_single = 74
ParserRULE_window_function = 75
ParserRULE_offset = 76
ParserRULE_default_value = 77
ParserRULE_partition_by = 78
ParserRULE_order_by_expr = 79
ParserRULE_order_by_expr_asc_desc = 80
ParserRULE_expr_asc_desc = 81
ParserRULE_initial_select = 82
ParserRULE_recursive_select = 83
ParserRULE_unary_operator = 84
ParserRULE_error_message = 85
ParserRULE_module_argument = 86
ParserRULE_column_alias = 87
ParserRULE_keyword = 88
ParserRULE_name = 89
ParserRULE_function_name = 90
ParserRULE_schema_name = 91
ParserRULE_table_name = 92
ParserRULE_table_or_index_name = 93
ParserRULE_column_name = 94
ParserRULE_collation_name = 95
ParserRULE_foreign_table = 96
ParserRULE_index_name = 97
ParserRULE_trigger_name = 98
ParserRULE_view_name = 99
ParserRULE_module_name = 100
ParserRULE_pragma_name = 101
ParserRULE_savepoint_name = 102
ParserRULE_table_alias = 103
ParserRULE_transaction_name = 104
ParserRULE_window_name = 105
ParserRULE_alias = 106
ParserRULE_filename = 107
ParserRULE_base_window_name = 108
ParserRULE_simple_func = 109
ParserRULE_aggregate_func = 110
ParserRULE_table_function_name = 111
ParserRULE_any_name = 112
)
// IParseContext is an interface to support dynamic dispatch.
type IParseContext interface {
antlr.ParserRuleContext
// GetParser returns the parser.
GetParser() antlr.Parser
// IsParseContext differentiates from other interfaces.
IsParseContext()
}
type ParseContext struct {
*antlr.BaseParserRuleContext
parser antlr.Parser
}
func NewEmptyParseContext() *ParseContext {
var p = new(ParseContext)
p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(nil, -1)
p.RuleIndex = ParserRULE_parse
return p
}
func (*ParseContext) IsParseContext() {}
func NewParseContext(parser antlr.Parser, parent antlr.ParserRuleContext, invokingState int) *ParseContext {
var p = new(ParseContext)
p.BaseParserRuleContext = antlr.NewBaseParserRuleContext(parent, invokingState)
p.parser = parser
p.RuleIndex = ParserRULE_parse
return p
}
func (s *ParseContext) GetParser() antlr.Parser { return s.parser }
func (s *ParseContext) EOF() antlr.TerminalNode {
return s.GetToken(ParserEOF, 0)
}
func (s *ParseContext) AllSql_stmt_list() []ISql_stmt_listContext {
children := s.GetChildren()
len := 0
for _, ctx := range children {
if _, ok := ctx.(ISql_stmt_listContext); ok {
len++
}
}
tst := make([]ISql_stmt_listContext, len)
i := 0
for _, ctx := range children {
if t, ok := ctx.(ISql_stmt_listContext); ok {
tst[i] = t.(ISql_stmt_listContext)
i++
}
}
return tst
}
func (s *ParseContext) Sql_stmt_list(i int) ISql_stmt_listContext {
var t antlr.RuleContext
j := 0
for _, ctx := range s.GetChildren() {
if _, ok := ctx.(ISql_stmt_listContext); ok {
if j == i {
t = ctx.(antlr.RuleContext)
break
}
j++
}
}
if t == nil {
return nil
}
return t.(ISql_stmt_listContext)
}
func (s *ParseContext) GetRuleContext() antlr.RuleContext {
return s
}
func (s *ParseContext) ToStringTree(ruleNames []string, recog antlr.Recognizer) string {
return antlr.TreesStringTree(s, ruleNames, recog)
}
func (s *ParseContext) EnterRule(listener antlr.ParseTreeListener) {
if listenerT, ok := listener.(ParserListener); ok {
listenerT.EnterParse(s)
}
}
func (s *ParseContext) ExitRule(listener antlr.ParseTreeListener) {
if listenerT, ok := listener.(ParserListener); ok {
listenerT.ExitParse(s)
}
}
func (s *ParseContext) Accept(visitor antlr.ParseTreeVisitor) interface{} {
switch t := visitor.(type) {
case ParserVisitor:
return t.VisitParse(s)
default:
return t.VisitChildren(s)
}
}
func (p *Parser) Parse() (localctx IParseContext) {
this := p
_ = this
localctx = NewParseContext(p, p.GetParserRuleContext(), p.GetState())
p.EnterRule(localctx, 0, ParserRULE_parse)
var _la int
defer func() {
p.ExitRule()
}()
defer func() {
if err := recover(); err != nil {
if v, ok := err.(antlr.RecognitionException); ok {
localctx.SetException(v)
p.GetErrorHandler().ReportError(p, v)
p.GetErrorHandler().Recover(p, v)
} else {
panic(err)
}
}
}()
p.EnterOuterAlt(localctx, 1)
p.SetState(229)
p.GetErrorHandler().Sync(p)
_la = p.GetTokenStream().LA(1)
for (((_la)&-(0x1f+1)) == 0 && ((1< 2 {
return nil, fmt.Errorf("unexpected number of changes found: %d", len(changes))
}
parseutil.RenameColumn(modify, r)
}
if r, ok := stmt.RenameTable(); ok {
changes = parseutil.RenameTable(changes, r)
}
return changes, nil
}
func isnull(t antlr.Tree) bool {
x, ok := t.(*ExprContext)
if !ok || x.GetChildCount() != 1 {
return false
}
l, ok := x.GetChild(0).(*Literal_valueContext)
return ok && l.GetChildCount() == 1 && len(l.GetTokens(ParserNULL_)) > 0
}
func unquote(s string) string {
if len(s) < 2 || s[0] != '`' || s[len(s)-1] != '`' {
return s
}
return s[1 : len(s)-1]
}
atlas-0.7.2/cmd/atlas/internal/sqlparse/sqliteparse/sqliteparse_test.go 0000664 0000000 0000000 00000006064 14314555116 0026432 0 ustar 00root root 0000000 0000000 // Copyright 2021-present The Atlas Authors. All rights reserved.
// This source code is licensed under the Apache 2.0 license found
// in the LICENSE file in the root directory of this source tree.
package sqliteparse_test
import (
"strconv"
"testing"
"ariga.io/atlas/cmd/atlas/internal/sqlparse/sqliteparse"
"ariga.io/atlas/sql/migrate"
"ariga.io/atlas/sql/schema"
"github.com/stretchr/testify/require"
)
func TestFixChange_RenameColumns(t *testing.T) {
var p sqliteparse.FileParser
_, err := p.FixChange(
nil,
"ALTER TABLE t RENAME COLUMN c1 TO c2",
nil,
)
require.Error(t, err)
_, err = p.FixChange(
nil,
"ALTER TABLE t RENAME COLUMN c1 TO c2",
schema.Changes{&schema.AddTable{}},
)
require.Error(t, err)
changes, err := p.FixChange(
nil,
"ALTER TABLE t RENAME COLUMN c1 TO c2",
schema.Changes{
&schema.ModifyTable{
Changes: schema.Changes{
&schema.DropColumn{C: schema.NewColumn("c1")},
&schema.AddColumn{C: schema.NewColumn("c2")},
},
},
},
)
require.NoError(t, err)
require.Equal(
t,
schema.Changes{
&schema.ModifyTable{
Changes: schema.Changes{
&schema.RenameColumn{From: schema.NewColumn("c1"), To: schema.NewColumn("c2")},
},
},
},
changes,
)
}
func TestFixChange_RenameTable(t *testing.T) {
var p sqliteparse.FileParser
changes, err := p.FixChange(
nil,
"ALTER TABLE t1 RENAME TO t2",
schema.Changes{
&schema.DropTable{T: schema.NewTable("t1")},
&schema.AddTable{T: schema.NewTable("t2")},
&schema.AddTable{T: schema.NewTable("t3")},
},
)
require.NoError(t, err)
require.Equal(
t,
schema.Changes{
&schema.RenameTable{From: schema.NewTable("t1"), To: schema.NewTable("t2")},
&schema.AddTable{T: schema.NewTable("t3")},
},
changes,
)
}
func TestColumnFilledBefore(t *testing.T) {
for i, tt := range []struct {
file string
pos int
wantFilled bool
wantErr bool
}{
{
file: `UPDATE t SET c = NULL;`,
pos: 100,
},
{
file: "UPDATE `t` SET c = 2;",
pos: 100,
wantFilled: true,
},
{
file: `UPDATE t SET c = 2 WHERE c IS NULL;`,
pos: 100,
wantFilled: true,
},
{
file: "UPDATE `t` SET `c` = 2 WHERE `c` IS NULL;",
pos: 100,
wantFilled: true,
},
{
file: `UPDATE t SET c = 2 WHERE c IS NOT NULL;`,
pos: 100,
wantFilled: false,
},
{
file: `UPDATE t SET c = 2 WHERE c <> NULL`,
pos: 100,
wantFilled: false,
},
{
file: `
UPDATE t1 SET c = 2 WHERE c IS NULL;
UPDATE t SET c = 2 WHERE c IS NULL;
`,
pos: 2,
wantFilled: false,
},
{
file: `
UPDATE t SET c = 2 WHERE c IS NULL;
UPDATE t1 SET c = 2 WHERE c IS NULL;
`,
pos: 30,
wantFilled: true,
},
} {
t.Run(strconv.Itoa(i), func(t *testing.T) {
var (
p sqliteparse.FileParser
f = migrate.NewLocalFile("file", []byte(tt.file))
)
filled, err := p.ColumnFilledBefore(f, schema.NewTable("t"), schema.NewColumn("c"), tt.pos)
require.Equal(t, err != nil, tt.wantErr, err)
require.Equal(t, filled, tt.wantFilled)
})
}
}
atlas-0.7.2/cmd/atlas/internal/sqlparse/sqlparse.go 0000664 0000000 0000000 00000003154 14314555116 0022332 0 ustar 00root root 0000000 0000000 // Copyright 2021-present The Atlas Authors. All rights reserved.
// This source code is licensed under the Apache 2.0 license found
// in the LICENSE file in the root directory of this source tree.
package sqlparse
import (
"sync"
"ariga.io/atlas/cmd/atlas/internal/sqlparse/myparse"
"ariga.io/atlas/cmd/atlas/internal/sqlparse/pgparse"
"ariga.io/atlas/cmd/atlas/internal/sqlparse/sqliteparse"
"ariga.io/atlas/sql/migrate"
"ariga.io/atlas/sql/mysql"
"ariga.io/atlas/sql/postgres"
"ariga.io/atlas/sql/schema"
"ariga.io/atlas/sql/sqlite"
)
// A Parser represents an SQL file parser used to fix, search and enrich schema.Changes.
type Parser interface {
// FixChange fixes the changes according to the given statement.
FixChange(d migrate.Driver, stmt string, changes schema.Changes) (schema.Changes, error)
// ColumnFilledBefore checks if the column was filled with values before the given position
// in the file. For example:
//
// UPDATE
SET =
// UPDATE
SET = WHERE IS NULL
//
ColumnFilledBefore(migrate.File, *schema.Table, *schema.Column, int) (bool, error)
}
// drivers specific fixers.
var drivers sync.Map
// Register a fixer with the given name.
func Register(name string, f Parser) {
drivers.Store(name, f)
}
// ParserFor returns a ChangesFixer for the given driver.
func ParserFor(name string) Parser {
f, ok := drivers.Load(name)
if ok {
return f.(Parser)
}
return nil
}
func init() {
Register(mysql.DriverName, &myparse.Parser{})
Register(postgres.DriverName, &pgparse.Parser{})
Register(sqlite.DriverName, &sqliteparse.FileParser{})
}
atlas-0.7.2/cmd/atlas/internal/update/ 0000775 0000000 0000000 00000000000 14314555116 0017576 5 ustar 00root root 0000000 0000000 atlas-0.7.2/cmd/atlas/internal/update/update.go 0000664 0000000 0000000 00000010112 14314555116 0021402 0 ustar 00root root 0000000 0000000 // Copyright 2021-present The Atlas Authors. All rights reserved.
// This source code is licensed under the Apache 2.0 license found
// in the LICENSE file in the root directory of this source tree.
package update
import (
"encoding/json"
"fmt"
"io"
"io/ioutil"
"net/http"
"os"
"path/filepath"
"time"
"github.com/mitchellh/go-homedir"
"golang.org/x/mod/semver"
)
type (
// Store is where the latest release data is stored on CLI host.
Store struct {
Version string `json:"version"`
URL string `json:"url"`
CheckedAt time.Time `json:"checkedat"`
}
// LatestRelease holds the required fields from https://api.github.com/repos/ariga/atlas/releases/latest.
LatestRelease struct {
Version string `json:"tag_name"`
URL string `json:"html_url"`
}
)
const (
// AtlasNoUpdateNotifier when enabled it cancels checking for update
AtlasNoUpdateNotifier = "ATLAS_NO_UPDATE_NOTIFIER"
)
// Check implements a notification to the user when a later release is available
// 1. Check release file ~/.atlas/release.json for latest known release and poll time
// 2. If last poll was more than 24h, poll GitHub public API https://docs.github.com/en/rest/reference/releases#get-the-latest-release
// 3. Store the latest release metadata
// 4. If current build Version, that is not development, is lower than the latest release, notify user
func Check(version string, logF func(i ...any)) {
if !enabled(version) {
return
}
p, err := homedir.Expand("~/.atlas")
if err != nil {
return
}
ok, message, err := shouldUpdate(version, p, latestReleaseFromGithub)
if err != nil || !ok {
return
}
logF(message)
}
func enabled(version string) bool {
if _, ok := os.LookupEnv(AtlasNoUpdateNotifier); ok {
return false
}
if _, ok := os.LookupEnv("GITHUB_ACTIONS"); ok {
return false
}
if ok := semver.IsValid(version); !ok {
return false
}
return true
}
func shouldUpdate(version string, path string, latestReleaseF func() (*LatestRelease, error)) (bool, string, error) {
r := localStore(path)
if shouldSkip(r) {
return false, "", nil
}
l, err := latestReleaseF()
if err != nil {
return false, "", err
}
if err := saveStore(path, l, time.Now()); err != nil {
return false, "", err
}
if semver.Compare(version, l.Version) != -1 {
return false, "", nil
}
return true, fmt.Sprintf("A new version of Atlas is available (%s):\n%s", l.Version, l.URL), nil
}
func latestReleaseFromGithub() (*LatestRelease, error) {
req, err := http.NewRequest(http.MethodGet, "https://api.github.com/repos/ariga/atlas/tags", nil)
if err != nil {
return nil, err
}
req.Header.Set("Content-Type", "application/json; charset=utf-8")
req.Header.Set("Accept", "application/vnd.github.v3+json")
// https://docs.github.com/en/rest/overview/resources-in-the-rest-api#user-agent-required
req.Header.Set("User-Agent", "Ariga-Atlas-CLI")
resp, err := http.DefaultClient.Do(req)
if err != nil {
return nil, err
}
b, err := io.ReadAll(resp.Body)
if err != nil {
return nil, err
}
var tags []tag
if err := json.Unmarshal(b, &tags); err != nil {
return nil, err
}
var max tag
for _, tag := range tags {
if !semver.IsValid(tag.Name) {
continue
}
if semver.Compare(tag.Name, max.Name) > 0 {
max = tag
}
}
return &LatestRelease{
Version: max.Name,
URL: fmt.Sprintf("https://github.com/ariga/atlas/releases/tag/%s", max.Name),
}, nil
}
func shouldSkip(r *Store) bool {
if r == nil {
return false
}
return time.Since(r.CheckedAt).Hours() < 24
}
func localStore(path string) *Store {
b, err := ioutil.ReadFile(fileLocation(path))
if err != nil {
return nil
}
var s Store
if err := json.Unmarshal(b, &s); err != nil {
return nil
}
return &s
}
func saveStore(path string, l *LatestRelease, t time.Time) error {
s := Store{Version: l.Version, URL: l.URL, CheckedAt: t}
err := os.MkdirAll(path, 0755)
if err != nil {
return err
}
b, err := json.Marshal(&s)
if err != nil {
return err
}
return ioutil.WriteFile(fileLocation(path), b, 0600)
}
func fileLocation(p string) string {
return filepath.Join(p, "release.json")
}
type tag struct {
Name string `json:"name"`
}
atlas-0.7.2/cmd/atlas/internal/update/update_test.go 0000664 0000000 0000000 00000006055 14314555116 0022454 0 ustar 00root root 0000000 0000000 // Copyright 2021-present The Atlas Authors. All rights reserved.
// This source code is licensed under the Apache 2.0 license found
// in the LICENSE file in the root directory of this source tree.
package update
import (
"encoding/json"
"fmt"
"io/ioutil"
"testing"
"time"
"github.com/stretchr/testify/require"
)
func TestCheckForUpdate(t *testing.T) {
url := "https://github.com/ariga/atlas/releases/tag/test"
tests := []struct {
name string
currentVersion string
latestVersion string
store *Store
latestRelease *LatestRelease
shouldNotify bool
message string
}{
{
name: "stale store fetch and update newer version",
currentVersion: "v1.2.3",
latestVersion: "v2.2.3",
store: &Store{Version: "v1.2.3", URL: url, CheckedAt: time.Now().Add(-25 * time.Hour)},
latestRelease: &LatestRelease{Version: "v2.2.3", URL: url},
shouldNotify: true,
message: fmt.Sprintf("A new version of Atlas is available (v2.2.3):\n%s", url),
},
{
name: "fresh store do nothing",
currentVersion: "v1.2.3",
latestVersion: "v2.2.3",
store: &Store{Version: "v1.2.3", URL: url, CheckedAt: time.Now().Add(-23 * time.Hour)},
shouldNotify: false,
},
{
name: "no store fetch and update newer version",
currentVersion: "v1.2.3",
latestVersion: "v2.2.3",
latestRelease: &LatestRelease{Version: "v2.2.3", URL: url},
shouldNotify: true,
message: fmt.Sprintf("A new version of Atlas is available (v2.2.3):\n%s", url),
},
{
name: "no store fetch and update newer minor version",
currentVersion: "v1.2.3",
latestVersion: "v1.3.3",
latestRelease: &LatestRelease{Version: "v2.2.3", URL: url},
shouldNotify: true,
message: fmt.Sprintf("A new version of Atlas is available (v2.2.3):\n%s", url),
},
{
name: "no store fetch and update newer patch version",
currentVersion: "v1.2.3",
latestVersion: "v1.2.4",
latestRelease: &LatestRelease{Version: "v2.2.3", URL: url},
shouldNotify: true,
message: fmt.Sprintf("A new version of Atlas is available (v2.2.3):\n%s", url),
},
{
name: "no store fetch and update newer patch version - canary",
currentVersion: "v1.2.3-6539f2704b5d-canary",
latestVersion: "v1.2.4",
latestRelease: &LatestRelease{Version: "v2.2.3", URL: url},
shouldNotify: true,
message: fmt.Sprintf("A new version of Atlas is available (v2.2.3):\n%s", url),
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
p := t.TempDir()
if tt.store != nil {
b, err := json.Marshal(tt.store)
require.NoError(t, err)
require.NoError(t, ioutil.WriteFile(fileLocation(p), b, 0600))
}
var f func() (*LatestRelease, error)
if tt.latestRelease != nil {
f = func() (*LatestRelease, error) { return tt.latestRelease, nil }
}
ok, m, err := shouldUpdate(tt.currentVersion, p, f)
require.NoError(t, err)
require.Equal(t, tt.shouldNotify, ok)
require.Equal(t, tt.message, m)
})
}
}
atlas-0.7.2/cmd/atlas/main.go 0000664 0000000 0000000 00000001567 14314555116 0015764 0 ustar 00root root 0000000 0000000 // Copyright 2021-present The Atlas Authors. All rights reserved.
// This source code is licensed under the Apache 2.0 license found
// in the LICENSE file in the root directory of this source tree.
package main
import (
"context"
"os"
"os/signal"
"ariga.io/atlas/cmd/atlas/internal/cmdapi"
_ "ariga.io/atlas/cmd/atlas/internal/docker"
_ "ariga.io/atlas/sql/mysql"
_ "ariga.io/atlas/sql/mysql/mysqlcheck"
_ "ariga.io/atlas/sql/postgres"
_ "ariga.io/atlas/sql/postgres/postgrescheck"
_ "ariga.io/atlas/sql/sqlite"
_ "ariga.io/atlas/sql/sqlite/sqlitecheck"
_ "github.com/go-sql-driver/mysql"
_ "github.com/lib/pq"
_ "github.com/mattn/go-sqlite3"
)
func main() {
ctx, _ := signal.NotifyContext(context.Background(), os.Interrupt, os.Kill)
cmdapi.Root.SetOut(os.Stdout)
err := cmdapi.Root.ExecuteContext(ctx)
cmdapi.CheckForUpdate()
if err != nil {
os.Exit(1)
}
}
atlas-0.7.2/doc/ 0000775 0000000 0000000 00000000000 14314555116 0013376 5 ustar 00root root 0000000 0000000 atlas-0.7.2/doc/md/ 0000775 0000000 0000000 00000000000 14314555116 0013776 5 ustar 00root root 0000000 0000000 atlas-0.7.2/doc/md/about.md 0000664 0000000 0000000 00000001043 14314555116 0015430 0 ustar 00root root 0000000 0000000 ---
title: About
id: about
slug: /about
---
# About Atlas
Atlas is an open-source project maintained by [Ariga Technologies Ltd](https://ariga.io),
a tech company founded by the maintainers of [Ent](https://entgo.io).
### Reaching Out
If you have a question or want to chat with the Atlas community,
join our [Discord Server](https://discord.com/invite/QhsmBAWzrC) or
[open an issue](https://github.com/ariga/atlas/issues) on our [GitHub Repo](https://github.com/ariga/atlas). atlas-0.7.2/doc/md/atlas-schema/ 0000775 0000000 0000000 00000000000 14314555116 0016340 5 ustar 00root root 0000000 0000000 atlas-0.7.2/doc/md/atlas-schema/input.md 0000664 0000000 0000000 00000004705 14314555116 0020027 0 ustar 00root root 0000000 0000000 ---
id: input-variables
slug: /atlas-schema/input-variables
title: Input Variables
---
In some cases, it is desirable to reuse an Atlas HCL document in different contexts.
For example, many organizations manage a multi-tenant architecture where the same database
schema is replicated per tenant. For this reason, the Atlas DDL supports input variables.
Input variables are defined using the `variable` block:
```hcl
variable "comment" {
type = string // | int | bool
default = "rotemtam"
}
```
Once defined, their value can be referenced using `var.`:
```hcl
schema "main" {
comment = var.comment
}
```
Finally, input variables are passed to Atlas in the `schema apply` command using the
`--var` flag:
```shell
atlas schema apply -u ... -f atlas.hcl --var comment="hello"
```
If a variable is not set from the command line, Atlas tries to use its default value.
If no default value is set, an error is returned:
```text
schemahcl: failed decoding: input value "tenant" expected but missing
```
### Variable schema names
Returning to the use case we described above, let's see how we can use input variables
to manage a multi-tenant architecture.
First, we define our schema in a file named `multi.hcl`:
```hcl title="multi.hcl"
// Define the input variable that contains the tenant name.
variable "tenant" {
type = string
}
// Define the schema, "tenant" here is a placeholder for the final
// schema name that will be defined at runtime.
schema "tenant" {
// Reference to the input variable.
name = var.tenant
}
table "users" {
// Refer to the "tenant" schema. It's actual name will be
// defined at runtime.
schema = schema.tenant
column "id" {
type = int
}
}
```
Now suppose we have two tenants, `jerry` and `george`. We can apply the same schema twice:
Once for Jerry:
```text
atlas schema apply -u mysql://user:pass@localhost:3306/ --schema jerry --var tenant=jerry
```
Observe the generated queries apply to the `jerry` schema:
```text
-- Planned Changes:
-- Add new schema named "jerry"
CREATE DATABASE `jerry`
-- Create "users" table
CREATE TABLE `jerry`.`users` (`id` int NOT NULL)
✔ Apply
```
And again for George:
```text
atlas schema apply -u mysql://user:pass@localhost:3306/ --schema george --var tenant=george
```
The generated queries create the `george` schema:
```text
-- Planned Changes:
-- Add new schema named "george"
CREATE DATABASE `george`
-- Create "users" table
CREATE TABLE `george`.`users` (`id` int NOT NULL)
✔ Apply
```
atlas-0.7.2/doc/md/atlas-schema/projects.md 0000664 0000000 0000000 00000010220 14314555116 0020506 0 ustar 00root root 0000000 0000000 ---
title: Project Structure
id: projects
slug: /atlas-schema/projects
---
### Project Files
Project files provide a convenient way to describe and interact with multiple
environments when working with Atlas. A project file is a file named
`atlas.hcl` and contains one or more `env` blocks. For example:
```hcl
// Define an environment named "local"
env "local" {
// Declare where the schema definition resides.
// Also supported:
// src = "./dir/with/schema"
// src = ["multi.hcl", "file.hcl"]
src = "./project/schema.hcl"
// Define the URL of the database which is managed in
// this environment.
url = "mysql://localhost:3306"
// Define the URL of the Dev Database for this environment
// See: https://atlasgo.io/concepts/dev-database
dev = "mysql://localhost:3307"
// The schemas in the database that are managed by Atlas.
schemas = ["users", "admin"]
}
env "dev" {
// ... a different env
}
```
Once defined, a project's environment can be worked against using the `--env` flag.
For example:
```shell
atlas schema apply --env local
```
Will run the `schema apply` command against the database that is defined for the `local`
environment.
### Projects with Versioned Migrations
Environments may declare a `migration` block to configure how versioned migrations
work in the specific environment:
```hcl
env "local" {
// ..
migration {
// URL where the migration directory resides. Only filesystem directories
// are currently supported but more options will be added in the future.
dir = "file://migrations"
// Format of the migration directory: atlas | flyway | liquibase | goose | golang-migrate
format = atlas
}
}
```
Once defined, `migrate` commands can use this configuration, for example:
```shell
atlas migrate validate --env local
```
Will run the `migrate validate` command against the Dev Database defined in the
`local` environment.
### Configure Migration Linting
Project files may declare `lint` blocks to configure how migration linting run in a specific environment or globally.
```hcl
lint {
destructive {
// By default, destructive changes cause migration linting to error
// on exit (code 1). Setting `error` to false disables this behavior.
error = false
}
// Custom logging can be enabled using the `log` attribute.
log = <
In MySQL and MariaDB, the `schema` resource can contain the `charset` and `collate` attributes. Read more about them
in [MySQL](https://dev.mysql.com/doc/refman/8.0/en/charset.html) or
[MariaDB](https://mariadb.com/kb/en/setting-character-sets-and-collations/) websites.
```hcl
# Schema with attributes.
schema "market" {
charset = "utf8mb4"
collate = "utf8mb4_0900_ai_ci"
comment = "A schema comment"
}
# Schema without attributes.
schema "orders" {}
```
```hcl
schema "public" {
comment = "A schema comment"
}
schema "private" {}
```
Atlas does not support [attached databases](https://www.sqlite.org/lang_attach.html), and support only the default
database (i.e. `main`).
```hcl
schema "main" {}
```
## Table
A `table` describes a table in a SQL database. A table hold its columns, indexes, constraints, and additional attributes
that are supported by the different drivers.
```hcl
table "users" {
schema = schema.public
column "id" {
type = int
}
column "name" {
type = varchar(255)
}
column "manager_id" {
type = int
}
primary_key {
columns = [
column.id
]
}
index "idx_name" {
columns = [
column.name
]
unique = true
}
foreign_key "manager_fk" {
columns = [column.manager_id]
ref_columns = [column.id]
on_delete = CASCADE
on_update = NO_ACTION
}
}
```
### Check
A `check` is a child resource of a `table` that describes a `CHECK` constraint.
```hcl
table "products" {
column "price" {
type = float
}
check "positive price" {
expr = "price > 0"
}
}
```
### Partitions
Table partitioning refers to splitting logical large tables into smaller physical ones.
:::note
Atlas currently only supports PostgreSQL. Support for the remaining dialects will be added in future versions.
:::
```hcl
table "logs" {
schema = schema.public
column "date" {
type = date
}
column "text" {
type = integer
}
partition {
type = RANGE
columns = [column.date]
}
}
table "metrics" {
schema = schema.public
column "x" {
type = integer
}
column "y" {
type = integer
}
partition {
type = RANGE
by {
column = column.x
}
by {
expr = "floor(y)"
}
}
}
```
### Table Qualification
In some cases, an Atlas DDL document may contain multiple tables of the same name. This usually happens
when the same table name appears in two different schemas. In these cases, the table names must be
disambiguated by using resource [qualifers](/guides/ddl.md#qualifiers). The following document describes a
database that contains two schemas named `a` and `b`, and both of them contain a table named `users`.
```hcl
schema "a" {}
schema "b" {}
table "a" "users" {
schema = schema.a
// .. columns
}
table "b" "users" {
schema = schema.b
// .. columns
}
```
## Column
A `column` is a child resource of a `table`.
```hcl
column "name" {
type = text
null = false
}
column "age" {
type = integer
default = 42
}
column "active" {
type = tinyint(1)
default = true
}
```
#### Properties
| Name | Kind | Type | Description |
|---------|-----------|-------------------------|------------------------------------------------------------|
| null | attribute | bool | Defines whether the column is nullable. |
| type | attribute | *schemahcl.Type | Defines the type of data that can be stored in the column. |
| default | attribute | *schemahcl.LiteralValue | Defines the default value of the column. |
### Generated Columns
Generated columns are columns whose their values are computed using other columns or by deterministic expressions.
```hcl
table "users" {
schema = schema.test
column "a" {
type = int
}
column "b" {
type = int
# In MySQL, generated columns are VIRTUAL by default.
as = "a * 2"
}
column "c" {
type = int
as {
expr = "a * b"
type = STORED
}
}
}
```
```hcl
table "users" {
schema = schema.test
column "a" {
type = int
}
column "b" {
type = int
# In PostgreSQL, generated columns are STORED by default.
as = "a * 2"
}
column "c" {
type = int
as {
expr = "a * b"
type = STORED
}
}
}
```
```hcl
table "users" {
schema = schema.test
column "a" {
type = int
}
column "b" {
type = int
# In SQLite, generated columns are VIRTUAL by default.
as = "a * 2"
}
column "c" {
type = int
as {
expr = "a * b"
type = STORED
}
}
}
```
:::info
Note, it is recommended to use the [`--dev-url`](../concepts/dev-database) option when generated columns are used.
:::
## Column Types
The SQL dialects supported by Atlas (Postgres, MySQL, MariaDB, and SQLite) vary in
the types they support. At this point, the Atlas DDL does not attempt to abstract
away the differences between various databases. This means that the schema documents
are tied to a specific database engine and version. This may change in a future version
of Atlas as we plan to add "Virtual Types" support. This section lists the various
types that are supported in each database.
For a full list of supported column types, [click here](sql-types.md).
## Primary Key
A `primary_key` is a child resource of a `table`, and it defines the table's
primary key.
#### Example
```hcl
primary_key {
columns = [column.id]
}
```
#### Properties
| Name | Kind | Type | Description |
|---------|-----------|--------------------------|----------------------------------------------------------------|
| columns | resource | reference (list) | A list of references to columns that comprise the primary key. |
## Foreign Key
Foreign keys are child resources of a `table`, and it defines some columns in the table
as references to columns in other tables.
#### Example
```hcl
foreign_key "manager_fk" {
columns = [column.manager_id]
ref_columns = [column.id]
on_delete = CASCADE
on_update = NO_ACTION
}
```
#### Referencing Qualified Tables
If a foreign key references a column in a [qualified](#table-qualification) table, it is referenced
using `table...column.`:
```hcl {3}
foreign_key "manager_fk" {
columns = [column.manager_id]
ref_columns = [table.other_schema.users.column.id]
on_delete = CASCADE
on_update = NO_ACTION
}
```
#### Properties
| Name | Kind | Type | Description |
|-------------|-----------|------------------------|-------------------------------------------|
| columns | attribute | reference (list) | The columns that reference other columns. |
| ref_columns | attribute | reference (list) | The referenced columns. |
| on_update | attribute | schema.ReferenceOption | Defines what to do on update. |
| on_delete | attribute | schema.ReferenceOption | Defines what to do on delete. |
## Index
Indexes are child resources of a `table`, and it defines an index on the table.
#### Example
```hcl
index "idx_name" {
columns = [
column.name
]
unique = true
}
index "idx_name" {
on {
column = column.rank
}
on {
column = column.score
desc = true
}
unique = true
}
index "idx_name" {
type = GIN
columns = [column.data]
}
index "idx_range" {
type = BRIN
columns = [column.range]
page_per_range = 128
}
index "idx_include" {
columns = [column.range]
include = [column.version]
}
```
#### Properties
| Name | Kind | Type | Description |
|-----------|-----------|-------------------------|----------------------------------------------------------------|
| unique | attribute | boolean | Defines whether a uniqueness constraint is set on the index. |
| type | attribute | IndexType (enum) | Defines the index type. e.g. `HASH`, `GIN`, `FULLTEXT`. |
| columns | attribute | reference (list) | The columns that comprise the index. |
| on | resource | schema.IndexPart (list) | The index parts that comprise the index. |
| options | attribute | schema.Attr | Additional driver specific attributes. e.g. `page_per_range` |
### Index Expressions
Index expressions allow setting indexes over functions or computed expressions. Supported by PostgreSQL, SQLite and
MySQL8.
```hcl {9-16}
table "t" {
schema = schema.test
column "c1" {
type = int
}
column "c2" {
type = int
}
index "i" {
on {
expr = "c1 - c2"
}
on {
expr = "c2 - c1"
}
}
}
```
:::info
Note, it is recommended to use the [`--dev-url`](../concepts/dev-database) option when index expressions are used.
:::
### Partial Indexes
[Partial indexes](https://www.postgresql.org/docs/current/indexes-partial.html) allow setting indexes over subset of
the table. Supported by PostgreSQL and SQLite.
```hcl {11}
table "t" {
schema = schema.public
column "b" {
type = bool
}
column "c" {
type = int
}
index "i" {
columns = [column.c]
where = "b AND c > 0"
}
}
```
:::info
Note, it is recommended to use the [`--dev-url`](../concepts/dev-database) option when partial indexes are used.
:::
### Index Prefixes
[Index prefixes](https://dev.mysql.com/doc/refman/8.0/en/column-indexes.html#column-indexes-prefix) allow setting an index
on the first `N` characters of string columns. Supported by MySQL and MariaDB.
```hcl {9}
table "users" {
schema = schema.test
column "name" {
type = varchar(255)
}
index "user_name" {
on {
column = column.name
prefix = 128
}
}
}
```
## Comment
The `comment` attribute is an attribute of `schema`, `table`, `column`, and `index`.
```hcl
schema "public" {
comment = "A schema comment"
}
table "users" {
schema = schema.public
column "name" {
type = text
comment = "A column comment"
}
index "name_idx" {
columns = [column.name]
}
comment = "A table comment"
}
```
## Charset and Collation
The `charset` and `collate` are attributes of `schema`, `table` and `column` and supported by MySQL, MariaDB and PostgreSQL.
Read more about them in [MySQL](https://dev.mysql.com/doc/refman/8.0/en/charset.html),
[MariaDB](https://mariadb.com/kb/en/setting-character-sets-and-collations/) and
[PostgreSQL](https://www.postgresql.org/docs/current/collation.html) websites.
```hcl
schema "public" {
charset = "utf8mb4"
collate = "utf8mb4_0900_ai_ci"
}
table "products" {
column "name" {
type = text
collate = "binary"
}
collate = "utf8_general_ci"
}
```
```hcl
schema "public" {}
table "products" {
column "name" {
type = text
collate = "es_ES"
}
}
```
## Auto Increment
`AUTO_INCREMENT` and `IDENTITY` columns are attributes of the `column` and `table` resource, and can be used to
generate a unique identity for new rows.
In MySQL/MariaDB the `auto_increment` attribute can be set on columns and tables.
```hcl
table "users" {
schema = schema.public
column "id" {
null = false
type = bigint
auto_increment = true
}
primary_key {
columns = [column.id]
}
}
```
The `auto_increment` column can be set on the table to configure a start value other than 1.
```hcl
table "users" {
schema = schema.public
column "id" {
null = false
type = bigint
auto_increment = true
}
primary_key {
columns = [column.id]
}
auto_increment = 100
}
```
PostgreSQL supports `serial` columns and the `generated as identity` syntax for versions >= 10.
```hcl
table "users" {
schema = schema.public
column "id" {
null = false
type = int
identity {
generated = ALWAYS
start = 10
increment = 10
}
}
primary_key {
columns = [column.id]
}
}
```
SQLite allows configuring [`AUTOINCREMENT`](https://www.sqlite.org/autoinc.html) columns using the `auto_increment`
attribute.
```hcl
table "users" {
schema = schema.main
column "id" {
null = false
type = integer
auto_increment = true
}
primary_key {
columns = [column.id]
}
}
```
atlas-0.7.2/doc/md/cloud/ 0000775 0000000 0000000 00000000000 14314555116 0015104 5 ustar 00root root 0000000 0000000 atlas-0.7.2/doc/md/cloud/getting-started.md 0000664 0000000 0000000 00000023451 14314555116 0020540 0 ustar 00root root 0000000 0000000 ---
id: getting-started
title: Getting Started with Ariga Cloud
sidebar_label: Getting Started
---
import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';
import Discord from '../../website/src/assets/icons/discord-white.svg'
[Ariga Cloud](https://ariga.cloud) is an online platform that allows developers to view their Atlas projects and track
their [Atlas GitHub Action](/integrations/github-actions) CI runs. The cloud platform gives full visibility into your
Atlas schema, by displaying an entity relation diagram (ERD) that shows the schema changes, as well as the entire
database schema.
### Signing Up
1. To get started with [Ariga Cloud](https://ariga.cloud/), create an account by clicking 'sign up' on the homepage.
2. In the sign up screen, enter your work email and choose a password.
3. Next, you will receive an email to verify your account. From your email, [Ariga Cloud](https://ariga.cloud/)
will open in a new tab, and you will need to sign in to access your account.
4. Once signed in, you will be prompted to create an organization. After creating the organization, you will be able
to invite team members to join. Choose a meaningful name for the organization, as it will also be your subdomain.
For example, "Acme Corp" will be available at "acme-corp.ariga.cloud".
:::note
Currently, the system only allows users to sign up for **one** organization. If you wish to create multiple
organizations under the same user, you can create a [task-specific email address](https://support.google.com/a/users/answer/9308648?hl=en)
(for Google users only). Create multiple emails that all link back to your regular address by adding a plus sign and
any word before the @ sign in your address.
:::
### Connecting to the Atlas GitHub action
At first you will notice that your projects and CI runs pages are empty. In order to connect the organization
to your GitHub repository, you will need to setup the Atlas GitHub action on your repository by following these steps:
:::note
If you already have the Atlas GitHub action set up, you may skip step 4. In step 5, only add
`ariga-token: ${{ secrets.ARIGA_TOKEN }}` to your yaml file.
:::
1. From the Settings page, generate an access token under 'Tokens'.
2. On your GitHub repo, under the 'Settings' section, click on 'Secrets' > 'Actions' to create a new repository secret.
3. Name your secret (for example, ARIGA_TOKEN) and paste the generated token from step 2.
4. Install the Atlas GitHub Action by adding a file named `.github/workflows/atlas-ci.yaml` to your repo.
5. Based on the type of database you are using, copy the following code into the workflow definition file. Set up
the `ariga-token` input parameter to the secret name you chose in the previous step, and ensure your
mainline branch and migration directory path are configured correctly:
```yaml
name: Atlas CI
on:
# Run whenever code is changed in the master branch,
# change this to your root branch.
push:
branches:
// highlight-next-line
- master
# Run on PRs where something changed under the `path/to/migration/dir/` directory.
pull_request:
paths:
// highlight-next-line
- 'path/to/migration/dir/*'
jobs:
lint:
services:
# Spin up a mysql:8.0.29 container to be used as the dev-database for analysis.
mysql:
image: mysql:8.0.29
env:
MYSQL_ROOT_PASSWORD: pass
MYSQL_DATABASE: test
ports:
- "3307:3306"
options: >-
--health-cmd "mysqladmin ping -ppass"
--health-interval 10s
--health-start-period 10s
--health-timeout 5s
--health-retries 10
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v3.0.1
with:
fetch-depth: 0 # Mandatory unless "latest" is set below.
- uses: ariga/atlas-action@v0
with:
// highlight-next-line
dir: 'path/to/migrations'
dir-format: atlas # Or: golang-migrate, goose, dbmate, flyway, liquibase
dev-url: mysql://root:pass@localhost:3307/test
// highlight-next-line
ariga-token: ${{ secrets.ARIGA_TOKEN }}
```
```yaml
name: Atlas CI
on:
# Run whenever code is changed in the master branch,
# change this to your root branch.
push:
branches:
// highlight-next-line
- master
# Run on PRs where something changed under the `path/to/migration/dir/` directory.
pull_request:
paths:
// highlight-next-line
- 'path/to/migration/dir/*'
jobs:
lint:
services:
# Spin up a postgres:14 container to be used as the dev-database for analysis.
postgres14:
image: postgres:14
env:
POSTGRES_DB: test
POSTGRES_PASSWORD: pass
ports:
- 5430:5432
options: >-
--health-cmd pg_isready
--health-interval 10s
--health-timeout 5s
--health-retries 5
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v3.0.1
with:
fetch-depth: 0 # Mandatory unless "latest" is set below.
- uses: ariga/atlas-action@v0
with:
// highlight-next-line
dir: 'path/to/migrations'
dir-format: atlas # Or: golang-migrate, goose, dbmate, flyway, liquibase
dev-url: postgres://postgres:pass@localhost:5430/test?sslmode=disable
// highlight-next-line
ariga-token: ${{ secrets.ARIGA_TOKEN }}
```
```yaml
name: Atlas CI
on:
# Run whenever code is changed in the master branch,
# change this to your root branch.
push:
branches:
// highlight-next-line
- master
# Run on PRs where something changed under the `path/to/migration/dir/` directory.
pull_request:
paths:
// highlight-next-line
- 'path/to/migration/dir/*'
jobs:
lint:
services:
# Spin up a maria:10.7 container to be used as the dev-database for analysis.
maria107:
image: mariadb:10.7
env:
MYSQL_DATABASE: test
MYSQL_ROOT_PASSWORD: pass
ports:
- 4306:3306
options: >-
--health-cmd "mysqladmin ping -ppass"
--health-interval 10s
--health-start-period 10s
--health-timeout 5s
--health-retries 10
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v3.0.1
with:
fetch-depth: 0 # Mandatory unless "latest" is set below.
- uses: ariga/atlas-action@v0
with:
// highlight-next-line
dir: 'path/to/migrations'
dir-format: atlas # Or: golang-migrate, goose, dbmate, flyway, liquibase
dev-url: maria://root:pass@localhost:4306/test
// highlight-next-line
ariga-token: ${{ secrets.ARIGA_TOKEN }}
```
6. After merging the workflow to your mainline branch, the workflow will be triggered.
7. Refresh Ariga Cloud and your project will appear!
### Viewing CI Runs
In the system, you can view all the CI runs that were triggered by the Atlas GitHub workflow.
Each run includes the following:
- A summary of the run.
- SQL statements that were analyzed.
- An ERD that shows the changes made to the schema, as well as a full view.
A run can complete in one of three ways:
The CI ran successfully and no errors or issues were found in your SQL statements or Atlas sum file.
In cases where your SQL statements _might_ cause a failure in production, the CI run will be labeled as 'issues
found'. In this example, we can see that the column `name` was created as non-nullable. The CI is letting us know that
this has a chance of causing a failure, because if there is a row that exists in this table that has a null `name`
value, this migration will for a fact fail in production.
The report also makes sure to reference the specific data-dependent check that was found
[MF103](https://atlasgo.io/lint/analyzers#MF103), in this example).
The CI run can fail for multiple reasons: incorrect SQL statements, wrong configuration, and more.
In this example, we can see the CI has failed due to an SQL statement that attempts to drop a table. Because this
is dangerous and will result in loss of data, the CI will automatically fail any `drop` statements.
However, users can disable this by configuring the destructive analyzer in the
[`atlas.hcl`](https://atlasgo.io/atlas-schema/projects) file:
```hcl title="atlas.hcl"
lint {
//highlight-start
destructive {
error = false
}
//highlight-end
}
```
### Inviting Members
Under 'Settings' > 'Members', you can invite team members to your organization.
These members will receive an email with a link to Ariga Cloud, and will be required to sign up with the same email
in order to access the organization.
### Regenerating Tokens
It is possible to regenerate the access token, however once you do so the old token will be **invalidated**.
When choosing to regenerate the token, you must remember to copy the new one into your GitHub project's 'Secrets'.
:::info
For more help, reach out to us on our [Discord server](https://discord.gg/zZ6sWVg6NT).
:::
atlas-0.7.2/doc/md/concepts/ 0000775 0000000 0000000 00000000000 14314555116 0015614 5 ustar 00root root 0000000 0000000 atlas-0.7.2/doc/md/concepts/dev.md 0000664 0000000 0000000 00000011720 14314555116 0016715 0 ustar 00root root 0000000 0000000 ---
title: Dev Database
id: dev-database
slug: /concepts/dev-database
---
## Introduction
Atlas uses the concept of "Dev Database" to provide extra safety and correctness to the migration process.
a development database (a twin environment) to validate schemas, simulate migrations and calculate the state of the
migration directory by replaying the historical changes. Let's go over a few examples to explain the benefits of using a
dev/twin database. For a one-time use Atlas can spin up an ephemeral local docker container for you with a special
[docker driver](concepts/url.mdx).
:::info
Atlas cleans up after itself! You can use the same instance of a "Dev Database" for multiple environments, as long
as they are not accessed concurrently.
:::
## Validation
Suppose we want to the add the following `CHECK` constraint to the table below:
```hcl title="test.hcl" {6-8}
table "t" {
schema = schema.test
column "c" {
type = int
}
check "ck" {
expr = "c <> d"
}
}
```
After running [`schema apply`](reference.md#atlas-schema-apply), we get the following error because the `CHECK`
constraint is invalid, as column `d` does not exist.
```shell
$ atlas schema apply --url "mysql://root:pass@:3308/test" -f test.hcl
```
```text
-- Planned Changes:
-- Modify "t" table
ALTER TABLE `test`.`t` ADD CONSTRAINT `ck` CHECK (c <> d), DROP COLUMN `c1`, ADD COLUMN `c` int NOT NULL
✔ Apply
Error: modify "t" table: Error 1054: Unknown column 'd' in 'check constraint ck expression'
exit status 1
```
Atlas cannot predict such errors without applying the schema file on the database, because some cases require parsing
and compiling SQL expressions, traverse their AST and validate them. This is already implemented by the database engine.
Migration failures can leave the database in a broken state. Some databases, like MySQL, do not support transactional
migrations due to [implicit COMMIT](https://dev.mysql.com/doc/refman/8.0/en/implicit-commit.html). However, this can be
avoided using the `--dev-url` option. Passing this to `schema apply` will first create and validate the desired state
(the HCL schema file) on temporary named-databases (schemas), and only then continue to `apply` the changes if it passed
successfully.
```shell
$ atlas schema apply --url "mysql://root:pass@:3308/test" -f test.hcl
--dev-url="mysql://root:pass@:3308/test"
```
```text
Error: create "t" table: Error 3820: Check constraint 'ck' refers to non-existing column 'd'.
exit status 1
```
## Diffing
Atlas adopts the declarative approach for maintaining the schemas desired state, but provides two ways to manage and
apply changes on the database: `schema apply` and `migrate diff`. In both commands, Atlas compares the "current", and the
"desired" states and suggests a migration plan to migrate the "current" state to the "desired" state. For example, the
"current" state can be an inspected database or a migration directory, and the "desired" state can be an inspected
database, or an HCL file.
Schemas that are written in HCL files are defined in natural form by humans. However, databases store schemas in
normal form (also known as canonical form). Therefore, when Atlas compares two different forms it may suggest incorrect
or unnecessary schema changes, and using the `--dev-url` option can solve this (see the above section for more
in-depth example).
Let's see it in action, by adding an index-expression to our schema.
```hcl title="test.hcl" {6-10}
table "t" {
schema = schema.test
column "c" {
type = varchar(32)
}
index "i" {
on {
expr = "upper(concat('c', c))"
}
}
}
```
```shell
$ atlas schema apply --url "mysql://root:pass@:3308/test" -f test.hcl
```
```text
-- Planned Changes:
-- Modify "t" table
ALTER TABLE `test`.`t` ADD INDEX `i` ((upper(concat('c', c))))
✔ Apply
```
We added a new index-expression to our schema, but using `schema inspect` will show our index in its normal form.
```shell
$ atlas schema inspect --url "mysql://root:pass@:3308/test"
```
```hcl {7-11}
table "t" {
schema = schema.test
column "c" {
null = false
type = varchar(32)
}
index "i" {
on {
expr = "upper(concat(_utf8mb4'c',`c`))"
}
}
}
```
Therefore, running `schema apply` again will suggest unnecessary schema changes.
```shell
$ atlas schema apply --url "mysql://root:pass@:3308/test" -f test.hcl
```
```text
-- Planned Changes:
-- Modify "t" table
ALTER TABLE `test`.`t` DROP INDEX `i`
-- Modify "t" table
ALTER TABLE `test`.`t` ADD INDEX `i` ((upper(concat('c', c))))
✔ Abort
```
Similarly to the previous example, we will use the `--dev-url` option to solve this.
```shell
$ atlas schema apply --url "mysql://root:pass@:3308/test" -f test.hcl
--dev-url="mysql://root:pass@:3307/test"
```
```text
Schema is synced, no changes to be made
```
Hooray! Our desired schema is synced and no changes have to be made.
:::info
Atlas cleans up after itself! You can use the same instance of a "Dev Database" for multiple environments, as long
as they are not accessed concurrently.
:::
atlas-0.7.2/doc/md/concepts/migration-directory-integrity.md 0000664 0000000 0000000 00000006407 14314555116 0024154 0 ustar 00root root 0000000 0000000 ---
id: migration-directory-integrity
slug: /concepts/migration-directory-integrity
title: Migration Directory Integrity File
---
Applying changes to a database schema in the wrong order can be dangerous. For this
reason, Atlas is built on a workflow that enforces a _linear history_ using a
_migration directory integrity file_.
### The problem
Suppose you have multiple teams working on a system simultaneously, all of which need to make
changes to the database schema from time to time. Unless they somehow coordinate, they
may end up with a broken migration directory.
Consider what would happen if Team A and B, working in parallel, both merge a migration
that creates a new table named `inventory`. This is illustrated in this diagram:
Something like this might happen:
1. Team A creates a feature branch, committing a migration creating the `inventory` table.
2. Team B creates a second feature branch, also creating a table by the same name.
3. Both branches pass code-review and continuous integration.
4. Team A's branch is merged to the mainline branch.
5. Team B's branch is merged.
6. When both changes are deployed, the first one to run will succeed and the second will fail.
This will happen in an arbitrary order (migrations are run in lexicographic order, usually set by the timestamp
on the developer's workstation when generating them).
### The solution
Recovering from a failed migration is quite a headache, so wouldn't it be great
to prevent this from ever happening?
Code conflicts are usually detected by source-control systems (such as Git) when
the same line in the same file is modified by two different commits. In our case,
no such conflict happens because migrations are typically described in a separate
file for each migration.
Atlas's engine offers a way to prevent concurrent creation of new migration
files and guards against accidental changes in the migration history we call
*Migration Directory Integrity File*. This file is simply another file in your
migration directory called `atlas.sum` and looks something like:
```text
h1:KRFsSi68ZOarsQAJZ1mfSiMSkIOZlMq4RzyF//Pwf8A=
20220318104614_team_A.sql h1:EGknG5Y6GQYrc4W8e/r3S61Aqx2p+NmQyVz/2m8ZNwA=
```
The `atlas.sum` file contains the checksum of each migration file (implemented by a
reverse, one branch merkle hash tree), and a sum of all files. Adding new files
results in a change to the sum file, which will raise merge conflicts in most
version control systems.
### How does this mechanism prevent situations like the one we described above?
The migration directory integrity file is updated automatically
whenever a new migration is created. Therefore, after Team A merged their changes to
the mainline branch, Team B would not be able to do so without dealing
with the changes landed by Team B.
Because of the merge conflict on the `atlas.sum` file, in order to land
their changes, Team B would need to:
1. Merge the latest changes into their branch
2. Resolve any conflicts on the database schema (and application) level
3. Re-compute the `atlas.sum` file (using the [`atlas migrate hash`](/cli-reference#atlas-migrate-hash))
command.
4. Merge their changes to the mainline branch.
atlas-0.7.2/doc/md/concepts/url.mdx 0000664 0000000 0000000 00000004332 14314555116 0017132 0 ustar 00root root 0000000 0000000 ---
title: URLs
id: concepts-url
slug: /concepts/url
---
import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';
## What is a URL?
Uniform Resource Locators, or URLs are a standardized method for specifying a location of a resource.
All the component parts of a URL are shown below:
```
driver://[username[:password]@]address/[schema|database][?param1=value1&...¶mN=valueN]
```
An example might look like:
```
mysql://localhost
mysql://user:pass@localhost
mysql://user:pass@localhost:3306/database
```
```
maria://localhost
maria://user:pass@localhost
maria://user:pass@localhost:3306/database
```
```
postgres://localhost:5432/database
postgres://localhost:5432/database?search_path=schema
postgres://postgres:pass@0.0.0.0:5432/database?sslmode=disable
```
```
sqlite://file.db
sqlite://file?cache=shared&mode=memory
```
Atlas can spin up an ephemeral local docker container for you by specifying a special URL like below. This can be useful
if you need a [dev database](../concepts/dev.md) for schema validation or diffing. However, some images like `mysql` /
`mariadb` take quite some time to "boot", before they are ready to be used. For a smoother developing experience
consider spinning up a longer lived container by yourself.
```
docker://postgres
docker://mysql/8
docker://mariadb/10.8.2-rc-focal
```
## SSL/TLS Mode
The default SSL mode for Postgres is `required`. Please follow the
[Postgres documentation](https://www.postgresql.org/docs/current/libpq-ssl.html)
for configuring your SSL connection for your database, or set SSL mode to `disable`
with the search parameter `?sslmode=disable`. For local databases,
disabling SSL is appropriate when inspecting and applying schema changes.
MySQL does not require TLS by default. However, you can require TLS
with the `?tls=true` search parameter.
atlas-0.7.2/doc/md/concepts/workflows.md 0000664 0000000 0000000 00000014611 14314555116 0020176 0 ustar 00root root 0000000 0000000 ---
title: Declarative vs Versioned Workflows
id: workflows
slug: /concepts/declarative-vs-versioned
---
This section introduces two types of workflows that are supported by Atlas
to manage database schemas: _declarative_ and _versioned_ migrations.
### Declarative Migrations
The declarative approach has become increasingly popular with engineers nowadays because it embodies
a convenient separation of concerns between application and infrastructure engineers.
Application engineers describe _what_ (the desired state) they need to happen, and
infrastructure engineers build tools that plan and execute ways to get to that state (_how_).
This division of labor allows for great efficiencies as it abstracts away the complicated
inner workings of infrastructure behind a simple, easy to understand API for the application
developers and allows for specialization and development of expertise to pay off for the
infra people.
With declarative migrations, the desired state of the database schema is given
as input to the migration engine, which plans and executes a set of actions to
change the database to its desired state.
For example, suppose your application uses a small SQLite database to store its data.
In this database, you have a `users` table with this structure:
```hcl
schema "main" {}
table "users" {
schema = schema.main
column "id" {
type = int
}
column "greeting" {
type = text
}
}
```
Now, suppose that you want to add a default value of `"shalom"` to the `greeting`
column. Many developers are not aware that it isn't possible to modify a column's
default value in an existing table in SQLite. Instead, the common practice is to
create a new table, copy the existing rows into the new table and drop the old one
after. Using the declarative approach, developers can change the default value for
the `greeting` column:
```hcl {10}
schema "main" {}
table "users" {
schema = schema.main
column "id" {
type = int
}
column "greeting" {
type = text
default = "shalom"
}
}
```
And have Atlas's engine devise a plan similar to this:
```sql
-- Planned Changes:
-- Create "new_users" table
CREATE TABLE `new_users` (`id` int NOT NULL, `greeting` text NOT NULL DEFAULT 'shalom')
-- Copy rows from old table "users" to new temporary table "new_users"
INSERT INTO `new_users` (`id`, `greeting`) SELECT `id`, IFNULL(`greeting`, 'shalom') AS `greeting` FROM `users`
-- Drop "users" table after copying rows
DROP TABLE `users`
-- Rename temporary table "new_users" to "users"
ALTER TABLE `new_users` RENAME TO `users`
```
### Versioned Migrations
As the database is one of the most critical components in any system, applying changes
to its schema is rightfully considered a dangerous operation. For this reason, many teams
prefer a more imperative approach where each change to the database schema is checked-in
to source control and reviewed during code-review. Each such change
is called a "migration", as it migrates the database schema from the previous version to
the next. To support this kind of requirement, many popular database schema management
tools such as [Flyway](https://flywaydb.org/), [Liquibase](https://liquibase.org/) or
[golang-migrate](https://github.com/golang-migrate/migrate) support a workflow that
is commonly called "versioned migrations".
In addition to the higher level of control which is provided by versioned migrations,
applications are often deployed to multiple remote environments at once. These environments,
are not controlled (or even accessible) by the development team. In such cases, declarative migrations,
which rely on a network connection to the target database and on human
approval of migrations plans in real-time, are not a feasible strategy.
With versioned migrations (sometimes called "change-based migrations") instead of describing
the desired state ("what the database should look like"), developers describe the changes themselves
("how to reach the state"). Most of the time, this is done by creating a set of SQL files
containing the statements needed. Each of the files is assigned a unique version and a
description of the changes. Tools like the ones mentioned earlier are then able to
interpret the migration files and to apply (some of) them in the correct order to
transition to the desired database structure.
The benefit of the versioned migrations approach is that it is explicit: engineers
know _exactly_ what queries are going to be run against the database when the time
comes to execute them. Because changes are planned ahead of time, migration authors
can control precisely how to reach the desired schema. If we consider a migration as
a plan to get from state A to state B, oftentimes multiple paths exist, each with a
very different impact on the database. To demonstrate, consider an initial state which
contains a table with two columns:
```sql
CREATE TABLE users (
id int,
name varchar(255)
);
```
Suppose our desired state is:
```sql
CREATE TABLE users (
id int,
user_name varchar(255)
);
```
There are at least two ways get from the initial to the desired state:
* Drop the `name` column and create a new `user_name` column.
* Alter the name of the `name` column to `user_name`.
Depending on the context, either may be the desired outcome for the developer
planning the change. With versioned migrations, engineers have the ultimate confidence
of what change is going to happen which may not be known ahead of time in a _declarative_
approach.
### Migration Authoring
The downside of the _versioned migration_ approach is, of course, that it puts the
burden of planning the migration on developers. This requires a certain level
of expertise that is not always available to every engineer, as we demonstrated
in our example of setting a default value in a SQLite database above.
As part of the Atlas project we advocate for a third combined approach that we call
"Versioned Migration Authoring". Versioned Migration Authoring is an attempt to combine
the simplicity and expressiveness of the declarative approach with the control and
explicitness of versioned migrations.
With versioned migration authoring, users still declare their desired state and use
the Atlas engine to plan a safe migration from the existing to the new state.
However, instead of coupling planning and execution, plans are instead written
into normal migration files which can be checked into source control, fine-tuned manually and
reviewed in regular code review processes.
atlas-0.7.2/doc/md/contributing.md 0000664 0000000 0000000 00000011335 14314555116 0017032 0 ustar 00root root 0000000 0000000 ---
title: Contributing
id: contributing
slug: /contributing
---
### How to Contribute
Atlas is a community project, we welcome contributions of all kinds and sizes!
Here are some ways in which you can help:
* File well-written and descriptive bug reports or feature requests in the [Issues page](https://github.com/ariga/atlas/issues).
* Tweet about your experience with Atlas on [Twitter](https://twitter.com), don't forget to mention
[@ariga_io](https://twitter.com/ariga_io) and link to [atlasgo.io](https://atlasgo.io) if you do.
* Write educational content on your personal blog or websites such as [dev.to](https://dev.to) or
[Medium](https://medium.com). If you do, don't hesitate to reach out to us via Discord (link below)
for help proof-reading your text and
using our social-media channels for distributing it to readers.
* Join our [Discord Server](https://discord.com/invite/QhsmBAWzrC) to answer questions of other users
and find out other ways in which you can contribute by talking to the community there!
* Contribute bug-fixes or new features to the [codebase](https://github.com/ariga/atlas).
### Contributing code to Atlas
As we are still starting out, we don't have an official code-style or guidelines on composing your
code. As general advice, read through the area of the code that you are modifying and try to keep your code
similar to what others have written in the same place.
#### Code-generation
Some of the code in the Atlas repository is generated. The CI process verifies that
all generated files are checked in by running `go generate ./...` and then running
`git status --porcelain`. Therefore, before committing changes to Atlas, please run:
```shell
go generate ./...
```
#### Linting
Your code will be linted using `golangci-lint` during CI. To install in locally,
[follow this guide](https://golangci-lint.run/usage/install/#local-installation).
To run it locally:
```shell
golangci-lint run
```
#### Formatting
Format your code using the standard `fmt` command:
```shell
go fmt ./...
```
#### Unit-tests
Your code should be covered in unit-tests, see the codebase for examples. To run tests:
```shell
go test ./...
```
#### Integration tests
Some features, especially those that interact directly with a database must be verified
in an integration test. There is extensive infrastructure for integration tests under
`internal/integration/` that runs tests under a matrix of database dialect (Postres, MySQL, etc.)
and versions. To run the integration tests, first use the `docker-compose.yml` file to spin up
databases to test against:
```shell
cd internal/integration
docker-compose up -d
```
Then run the tests, from with the `integration` directory:
```shell
go test ./...
```
### Contributing documentation
The Atlas documentation website is generated from the project's main [GitHub repo](https://github.com/ariga/atlas).
Follow this short guide to contribute documentation improvements and additions:
#### Setting Up
1. [Locally fork and clone](https://docs.github.com/en/github/getting-started-with-github/quickstart/fork-a-repo) the
[repository](https://github.com/ariga/atlas).
2. The documentation site uses [Docusaurus](https://docusaurus.io/). To run it you will need [Node.js installed](https://nodejs.org/en/).
3. Install the dependencies:
```shell
cd doc/website && npm install
```
4. Run the website in development mode:
```shell
cd doc/website && npm start
```
5. Open you browser at [http://localhost:3000](http://localhost:3000).
#### General Guidelines
* Documentation files are located in `doc/md`, they are [Markdown-formatted](https://en.wikipedia.org/wiki/Markdown)
with "front-matter" style annotations at the top. [Read more](https://docusaurus.io/docs/docs-introduction) about
Docusaurus's document format.
* Atlas uses [Golang CommitMessage](https://github.com/golang/go/wiki/CommitMessage) formats to keep the repository's
history nice and readable. As such, please use a commit message such as:
```text
doc/md: adding a guide on contribution of docs to atlas
```
#### Adding New Documents
1. Add a new Markdown file in the `doc/md` directory, for example `doc/md/writing-docs.md`.
2. The file should be formatted as such:
```markdown
---
id: writing-docs
title: Writing Docs
---
...
```
Where `id` should be a unique identifier for the document, and should be the same as the filename without the `.md` suffix,
and `title` is the title of the document as it will appear in the page itself and any navigation element on the site.
3. If you want the page to appear in the documentation website's sidebar, add a `doc` block to `website/sidebars.js`, for example:
```diff
{
type: 'doc',
id: 'writing-docs',
},
+ {
+ type: 'doc',
+ id: 'contributing',
+ },
``` atlas-0.7.2/doc/md/declarative/ 0000775 0000000 0000000 00000000000 14314555116 0016261 5 ustar 00root root 0000000 0000000 atlas-0.7.2/doc/md/declarative/apply.md 0000664 0000000 0000000 00000004000 14314555116 0017722 0 ustar 00root root 0000000 0000000 ---
id: apply
slug: /declarative/apply
title: Declarative schema migrations
---
With Atlas, users do not need to plan database schema changes themselves. Instead
of figuring out the correct SQL statements to get their database to the desired state,
Atlas supports a kind of workflow that we call _declarative schema migration_.
With declarative schema migrations the user provides a connection string to the target database
and the desired schema and Atlas does all of the planning.
[Read more about declarative workflows](/concepts/declarative-vs-versioned)
### Auto-approval
Before executing the migration against the target database, Atlas will print the SQL
statements that it is going to run and prompt the user for approval. Users that wish
to automatically approve may run the `schema apply` command with the `--auto-approve`
flag.
### Dry-runs
In order to skip the execution of the SQL queries against the target database,
users may provide the `--dry-run` flag. When invoked with this flag, Atlas will
connect to the target database, inspect its current state, calculate the diff
between the provided desired schema and print out a series of SQL statements to
reconcile any gaps between the inspected and desired schemas.
### Dev-database
When storing schema definitions, many database engines perform some form of
normalization. That is, despite us providing a specific definition of some
aspect of the schema, the database will store it in another, equivalent form.
This means in certain situations it may appear to Atlas as if some diff exists
between the desired and inspected schemas, whereas in reality there is none.
To overcome these situations, users may use the `--dev-url` flag to provide
Atlas with a connection string to a _Dev-Database_.
This database is used to normalize the schema prior to planning migrations and
for simulating changes to ensure their applicability before execution.
[Read more about Dev-Databases](/concepts/dev-database)
### Reference
[CLI Command Reference](/cli-reference#atlas-schema-apply)atlas-0.7.2/doc/md/declarative/diff.mdx 0000664 0000000 0000000 00000005307 14314555116 0017710 0 ustar 00root root 0000000 0000000 ---
id: diff
slug: /declarative/diff
title: Declarative schema migrations
---
import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';
It is sometimes useful to be able to calculate the diff between two
databases. For instance, as you are developing you may want to calculate
how to move from an existing database to some other state that you are
interested in. Alternatively, you may be diagnosing some issue and want
to verify there is no difference between a local copy of a schema and a
remote one.
To accommodate these types of use-cases, Atlas supports the `schema diff`
command. This command connects to two given databases, inspects
them, calculates the difference in their schemas, and prints a plan of
SQL statements to migrate the "from" database to the schema of the "to" database.
### Flags
* `--from` (required) - the [URL](/concepts/url) of the database to calculate the
diff from.
* `--to` (required) - the [URL](/concepts/url) of the database to calculate the
diff to.
### Examples
Diff to a remote database:
```
atlas schema diff --from "mysql://user:pass@localhost:3306" --to "mysql://user:pass@remote:3306"
```
Diff to a remote schema
```
atlas schema diff --from "mysql://user:pass@localhost:3306/schema" --to "mysql://user:pass@remote:3306/schema"
```
Diff to another schema in the same database
```
atlas schema diff --from "mysql://user:pass@localhost:3306/schema" --to "mysql://user:pass@localhost:3306/other"
```
Diff to a remote database:
```
atlas schema diff --from "maria://user:pass@localhost:3306" --to "maria://user:pass@remote:3306"
```
Diff to a remote schema
```
atlas schema diff --from "maria://user:pass@localhost:3306/schema" --to "maria://user:pass@remote:3306/schema"
```
Diff to another schema in the same database
```
atlas schema diff --from "maria://user:pass@localhost:3306/schema" --to "maria://user:pass@localhost:3306/other"
```
Diff to a remote database:
```
atlas schema diff --from "postgres://localhost:5432/database" --to "postgres://remote:5432/database"
```
Diff to a remote schema:
```
atlas schema diff --from "postgres://localhost:5432/database?search_path=schema" --to "postgres://remote:5432/database?search_path=schema"
```
Diff to another schema in the same database
```
atlas schema diff --from "postgres://localhost:5432/database?search_path=schema" --to "postgres://localhost:5432/database?search_path=other"
```
### Reference
[CLI Command Reference](/cli-reference#atlas-schema-diff) atlas-0.7.2/doc/md/declarative/inspect.mdx 0000664 0000000 0000000 00000010250 14314555116 0020436 0 ustar 00root root 0000000 0000000 ---
id: inspect
slug: /declarative/inspect
title: Inspecting existing schemas with Atlas
---
import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';
### Automatic Schema Inspection
Many projects begin with an existing database that users wish to start managing
with Atlas. In this case, instead of having developers learn the [Atlas Language](/atlas-schema/sql-resources)
and reverse engineer a schema definition file that precisely describes the existing database,
Atlas supports _automatic schema inspection_.
With automatic schema inspection, users simply provide Atlas with a connection string
to their target database and Atlas prints out a schema definition file in the Atlas
language that they can use as the starting point for working with this database.
### Flags
When using `schema inspect` to inspect an existing database, users may supply multiple
parameters:
* `--url` (required, `-u` accepted as well) - the [URL](/concepts/url) of database to be inspected.
* `--schema` (optional, may be supplied multiple times) - schemas to inspect within
the target database.
* `--exclude` (optional, may be supplied multiple times) - filter out resources matching the given glob pattern.
### Examples
#### Entire Database
```
atlas schema inspect -u "mysql://localhost"
atlas schema inspect -u "mysql://user:pass@localhost:3306"
```
```
atlas schema inspect -u "maria://localhost"
atlas schema inspect -u "maria://user:pass@localhost:3306"
```
```
atlas schema inspect -u "postgres://localhost:5432/database"
atlas schema inspect -u "postgres://postgres:pass@0.0.0.0:5432/database?sslmode=disable"
```
```
atlas schema inspect -u "sqlite://file.db"
atlas schema inspect -u "sqlite://file?cache=shared&mode=memory"
```
#### Single Schema
```
atlas schema inspect -u "mysql://localhost/schema"
atlas schema inspect -u "mysql://user:pass@localhost:3306/schema"
```
```
atlas schema inspect -u "maria://localhost/schema"
atlas schema inspect -u "maria://user:pass@localhost:3306/schema"
```
```
atlas schema inspect -u "postgres://localhost:5432/database?search_path=schema"
atlas schema inspect -u "postgres://postgres:pass@0.0.0.0:5432/database?sslmode=disable&sslmode=disable"
```
#### Multiple Schemas
```
atlas schema inspect -u "mysql://localhost" --schema schema1 --schema schema2
atlas schema inspect -u "mysql://user:pass@localhost:3306" -s schema1,schema2
```
```
atlas schema inspect -u "maria://localhost" --schema schema1 --schema schema2
atlas schema inspect -u "maria://user:pass@localhost:3306" -s schema1,schema2
```
```
atlas schema inspect -u "postgres://localhost:5432/database" --schema schema1 --schema schema2
atlas schema inspect -u "postgres://postgres:pass@0.0.0.0:5432/database?sslmode=disable" -s schema1,schema2
```
#### Exclude Schemas
```
atlas schema inspect -u "mysql://localhost" --exclude "internal"
atlas schema inspect -u "mysql://localhost" --exclude "schema_*"
```
#### Exclude Tables
```
atlas schema inspect -u "mysql://localhost" --exclude "*.prefix_*"
atlas schema inspect -u "mysql://localhost" --exclude "schema.table"
```
#### Exclude Table Resources
```
atlas schema inspect -u "mysql://localhost" --exclude "*.*.prefix_*"
atlas schema inspect -u "mysql://localhost" --exclude "public.*.c1"
```
### Reference
[CLI Command Reference](/cli-reference#atlas-schema-inspect)
atlas-0.7.2/doc/md/deployment/ 0000775 0000000 0000000 00000000000 14314555116 0016156 5 ustar 00root root 0000000 0000000 atlas-0.7.2/doc/md/deployment/intro.md 0000664 0000000 0000000 00000010267 14314555116 0017641 0 ustar 00root root 0000000 0000000 ---
id: deployment
slug: /deployment/intro
title: Deployment
---
## Introduction
:::info
As our team is working on completely rewriting The Management UI, support for it has been temporarily removed in the most recent version of Atlas. To explore the UI in previous versions, download [v0.3.7](https://github.com/ariga/atlas/releases/tag/v0.3.7) or earlier.
:::
Teams using Atlas to manage their databases can benefit from deploying the Atlas Management UI to their
cloud environment. The Management UI can be used to gain visibility of your team's database schemas as well
as provide an intuitive interface for planning and running database migrations using Atlas's core engine.
In addition, the Management UI automatically tracks and audits all changes using the "Activity & History" feature.
The Atlas Management UI is designed to be a long-running process.
It is therefore recommended running it against a persistent database that will make sure your team's schemas,
database credentials, migration history and more are not lost in case you need to restart the service.
Atlas uses [tink](https://developers.google.com/tink), a battle-tested encryption library created at Google, to encrypt all sensitive information.
Following recommendations from the developers of tink, Atlas uses [AEAD](https://developers.google.com/tink/aead?hl=en)
encryption with an AES256_GCM type key.
In this section we will review two deployment and usage options:
1. Deploying on a VM/EC2 instance with persistent storage.
2. Deploying using an official Atlas Docker container.
### Persistent Storage
When serving Atlas on a VM/EC2, you will need to decide on which persistent storage you would like Atlas to store the
configuration data.
For now, you can choose any of the supported databases:
1. SQLite (file) (in-memory is also supported but does not require encryption)
2. MySQL
3. TiDB
4. MariaDB
5. PostgresDB
An example for serving Atlas with MySQL persistent storage:
```
atlas serve --storage "mysql://root:pass@localhost:3306/atlas"
```
On your first run, Atlas will generate an encryption key and store it under ```$HOME/.atlas/keyset.json```.
This (private) file should not be deleted, otherwise Atlas will not be able to restore your configuration data.
### Docker
Atlas has an official docker that is updated with the latest and tagged versions,
which can be found on [Docker Hub](https://hub.docker.com/r/arigaio/atlas).
You can use this image to run the CLI and to serve the Atlas UI.
To run Atlas in served and persisted mode inside a container:
```
docker run -v $HOME/.atlas/keyset.json:/root/.atlas/keyset.json -p 5800:5800 arigaio/atlas:latest serve --addr :5800 --storage "mysql://root:pass@tcp(host.docker.internal:3306)/atlas"
```
Let's review this command step by step:
1. ```docker run``` - running a command.
2. ```-v $HOME/.atlas/keyset.json:/root/.atlas/keyset.json``` binds a secret key from a persisted host into the docker container. If you don't have a key, use an empty file and Atlas will generate one for you.
3. ``` -p 5800:5800``` binds an exposed serving port for connecting with a web client.
4. ```5800:5800 arigaio/atlas:latest``` use the latest atlas image, for a versioned release use a specific tag such as ```arigaio/atlas:0.3.6```.
5. ```serve --addr :5800 --storage "mysql://root:pass@tcp(host.docker.internal:3306)/atlas"``` serve Atlas on port 5800 with a persistent MySQL Database.
### Encryption
On its first run, Atlas generates a keyset.json file under `$HOME/.atlas/` containing
an encryption keyset for you. Do not lose this file! Without this file you cannot later use
any database credentials that save to Atlas.
If you want to generate this key yourself, you can
[install Tinkey](https://developers.google.com/tink/install-tinkey), Tink's official CLI,
and use it to generate a keyset:
```shell
brew tap google/tink https://github.com/google/tink
brew install tinkey
tinkey create-keyset --key-template AES256_GCM --out ~/.atlas/keyset.json
```
Alternatively, you can use [rotemtam/tinkey](https://hub.docker.com/r/rotemtam/tinkey), an unofficial Docker image that
wraps the official binary distribution:
```shell
docker run --rm rotemtam/tinkey create-keyset --key-template AES256_GCM > ~/.atlas/keyset.json
```
atlas-0.7.2/doc/md/getting-started/ 0000775 0000000 0000000 00000000000 14314555116 0017103 5 ustar 00root root 0000000 0000000 atlas-0.7.2/doc/md/getting-started/02-inspecting.mdx 0000664 0000000 0000000 00000013515 14314555116 0022204 0 ustar 00root root 0000000 0000000 ---
id: getting-started-inspection
title: Inspecting Schemas
slug: /cli/getting-started/inspection
---
import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';
Atlas features a Data Definition Language (DDL) that has an [HCL-syntax](https://github.com/hashicorp/hcl)
for defining the desired state of database schemas. In this section we will learn how to use the Atlas
CLI to inspect an existing database and write it's schema in HCL to a file.
Inspection is done via the `atlas schema inspect` command. To learn about its parameters, run:
```shell
atlas schema inspect --help
```
### Inspecting our database
To inspect our locally-running MySQL instance from the [previous](/getting-started/) section,
use the `-u` flag and write output to a file named `schema.hcl`:
```shell
atlas schema inspect -u "mysql://root:pass@localhost:3306/example" > schema.hcl
```
Then, view the contents of the file:
```hcl title="schema.hcl"
schema "example" {
charset = "utf8mb4"
collate = "utf8mb4_0900_ai_ci"
}
```
```shell
atlas schema inspect -u "maria://root:pass@localhost:3306/example" > schema.hcl
```
Then, view the contents of the file:
```hcl title="schema.hcl"
schema "example" {
charset = "utf8mb4"
collate = "utf8mb4_0900_ai_ci"
}
```
```shell
atlas schema inspect -u "postgres://postgres:pass@localhost:5432/example?sslmode=disable" > schema.hcl
```
Then, view the contents of the file:
```hcl title="schema.hcl"
schema "public" {
}
```
```shell
atlas schema inspect -u "sqlite://file.db" > schema.hcl
```
Then, view the contents of the file:
```hcl title="schema.hcl"
schema "main" {
}
```
As you can see, Atlas inspected our (empty) database and wrote an Atlas HCL document
containing only a [Schema](../atlas-schema/sql.mdx#schema) resource.
Next, let's create some tables in our SQL database and see how they are reflected
in the inspected Atlas HCL document.
### Modifying our database schema manually
In your database command-line prompt, create the tables:
```sql
CREATE table users (
id int PRIMARY KEY,
name varchar(100)
);
CREATE TABLE blog_posts (
id int PRIMARY KEY,
title varchar(100),
body text,
author_id int,
FOREIGN KEY (author_id) REFERENCES users(id)
);
```
Observe that the tables are created successfully:
```text
Query OK, 0 rows affected (0.02 sec)
```
Our schema represents a highly simplified blogging system with a `users` table for the authors and a `blog_posts` table
for the contents:
### Inspecting table schemas with Atlas CLI
Next, let's re-run our inspection command:
```shell
atlas schema inspect -u "mysql://root:pass@localhost:3306/example" > schema.hcl
```
```shell
atlas schema inspect -u "maria://root:pass@localhost:3306/example" > schema.hcl
```
```shell
atlas schema inspect -u "postgres://postgres:pass@localhost:5432/example?sslmode=disable" > schema.hcl
```
```shell
atlas schema inspect -u "sqlite://file.db" > schema.hcl
```
Browse through the updated contents of the file, it contains 3 blocks representing
our schema as before, and two new blocks representing the `users` and `blog_posts` tables.
Consider the following block:
```hcl
table "users" {
schema = schema.example
column "id" {
null = false
type = int
}
column "name" {
null = true
type = varchar(100)
}
primary_key {
columns = [column.id]
}
}
```
This block represents a [Table](../atlas-schema/sql.mdx#table) resource with `id`, and `name`
columns. The `schema` field references the `example` schema that is defined elsewhere
in this document. In addition, the `primary_key` sub-block defines the `id` column as
the primary key for the table. In SQL databases, columns usually have a type attribute
that defines the kind of data that can be stored in that column. Atlas strives to
mimic the syntax of the database that the user is working against. In this case, the
type for the `id` column is `int`, and `varchar(100)` for the `name` column. To
see the full list of supported types, [click here](../atlas-schema/sql-types.md).
Next, consider this block:
```hcl
table "blog_posts" {
schema = schema.example
column "id" {
null = false
type = int
}
column "title" {
null = true
type = varchar(100)
}
column "body" {
null = true
type = text
}
column "author_id" {
null = true
type = int
}
primary_key {
columns = [column.id]
}
foreign_key "blog_posts_ibfk_1" {
columns = [column.author_id]
ref_columns = [table.users.column.id]
on_update = NO_ACTION
on_delete = NO_ACTION
}
index "author_id" {
unique = false
columns = [column.author_id]
}
}
```
This block represents the `blog_posts` table. In addition to the elements
we saw in the `users` table, here we can find a [Foreign Key](../atlas-schema/sql.mdx#foreign-key)
block, declaring that the `author_id` column references the `id` column on the
`users` table.
To learn more about the resource types that are available to describe SQL schemas,
read the [SQL Syntax](../atlas-schema/sql.mdx) documentation.
In the next section, we will see how we can modify our database's schema by
applying a modified Atlas HCL file using the Atlas CLI.
atlas-0.7.2/doc/md/getting-started/03-applying.mdx 0000664 0000000 0000000 00000013333 14314555116 0021663 0 ustar 00root root 0000000 0000000 ---
id: getting-started-apply
title: Applying Schemas
slug: /cli/getting-started/applying-schemas
---
import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';
### Declarative migrations
In the previous section, we learned how to inspect an existing database and write
its schema as an Atlas DDL HCL file. In this section, we will learn how to use
the Atlas CLI to modify a database's schema. To do this, we will use Atlas's
`atlas schema apply` command which takes a _declarative_ approach, that is,
we define the _desired_ end schema, and Atlas figures out a safe-way to alter
the database to get there.
Let's start by viewing the help text for the `apply` command:
```shell
atlas schema apply --help
```
You can see that similar to the `inspect` command, the `-u` flag is used to define the
URL to connect to the database, and an additional flag `-f` specifies the path to
the file containing the desired schema.
### Adding new tables to our database
Let's modify our simplified blogging platform schema from the previous step by adding
a third table, `categories`. Each table will have an `id` and a `name`. In addition,
we will create an association table `post_categories` which creates a many-to-many
relationship between blog posts and categories:
First, let's store the existing schema in a file named `schema.hcl`:
```shell
atlas schema inspect -u "mysql://root:pass@localhost:3306/example" > schema.hcl
```
```shell
atlas schema inspect -u "maria://root:pass@localhost:3306/example" > schema.hcl
```
```shell
atlas schema inspect -u "postgres://postgres:pass@localhost:5432/example?sslmode=disable" > schema.hcl
```
```shell
atlas schema inspect -u "sqlite://file.db" > schema.hcl
```
Next, add the following table definition to the file:
```hcl
table "categories" {
schema = schema.example
column "id" {
null = false
type = int
}
column "name" {
null = true
type = varchar(100)
}
primary_key {
columns = [column.id]
}
}
```
To add this table to our database, let's use the `atlas schema apply` command:
```shell
atlas schema apply -u "mysql://root:pass@localhost:3306/example" -f schema.hcl
```
```shell
atlas schema apply -u "maria://root:pass@localhost:3306/example" -f schema.hcl
```
```shell
atlas schema apply -u "postgres://postgres:pass@localhost:5432/example?sslmode=disable" -f schema.hcl
```
```shell
atlas schema apply -u "sqlite://file.db" -f schema.hcl
```
Atlas plans a migration (schema change) for us and prompts us to approve it:
```text
-- Planned Changes:
-- Create "categories" table
CREATE TABLE `example`.`categories` (`id` int NOT NULL, `name` varchar(100) NULL, PRIMARY KEY (`id`))
Use the arrow keys to navigate: ↓ ↑ → ←
? Are you sure?:
▸ Apply
Abort
```
To apply the migration, press `ENTER`, and voila!
```text
✔ Apply
```
To verify that our new table was created, open the database command line tool from previous step and run:
```text
mysql> show create table categories;
+------------+------------------------------------------------------+
| Table | Create Table |
+------------+------------------------------------------------------+
| categories | CREATE TABLE `categories` (
`id` int NOT NULL,
`name` varchar(100) DEFAULT NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci |
+------------+------------------------------------------------------
1 row in set (0.01 sec)
```
Amazing! Our new table was created. Next, let's define our association table,
add the following block to our `schema.hcl` file:
```hcl
table "post_categories" {
schema = schema.example
column "post_id" {
type = int
}
column "category_id" {
type = int
}
foreign_key "post_category_post" {
columns = [column.post_id]
ref_columns = [table.blog_posts.column.id]
}
foreign_key "post_category_category" {
columns = [column.category_id]
ref_columns = [table.categories.column.id]
}
}
```
This block defines the `post_categories` table with two columns `post_id` and `category_id`.
In addition, two foreign-keys are created referencing the respective columns on the `blog_posts`
and `categories` tables.
Let's try to apply the schema again, this time with the updated schema:
```text
atlas schema apply -u "mysql://root:pass@localhost:3306/example" -f schema.hcl
-- Planned Changes:
-- Create "post_categories" table
CREATE TABLE `example`.`post_categories` (`post_id` int NOT NULL, `category_id` int NOT NULL, CONSTRAINT `post_category_post` FOREIGN KEY (`post_id`) REFERENCES `example`.`blog_posts` (`id`), CONSTRAINT `post_category_category` FOREIGN KEY (`category_id`) REFERENCES `example`.`categories` (`id`))
✔ Apply
```
### Conclusion
In this section, we've seen how to use the `atlas schema apply` command to migrate
the schema of an existing database to our desired state.
atlas-0.7.2/doc/md/getting-started/getting-started.mdx 0000664 0000000 0000000 00000021411 14314555116 0022721 0 ustar 00root root 0000000 0000000 ---
id: getting-started
title: Quick Introduction
sidebar_label: Quick Introduction
---
import Tabs from '@theme/Tabs';
import TabItem from '@theme/TabItem';
import Discord from '../../website/src/assets/icons/discord-white.svg'
Atlas CLI is an open-source tool designed to help software engineers, DBAs and DevOps
practitioners to manage their database schemas. Atlas users can use the [Atlas DDL](../atlas-schema/sql-resources)
(data-definition language) to describe the desired database schema and use the command-line
tool to plan and apply the migrations to their systems.
### Installation
Get the latest release with [Homebrew](https://brew.sh/):
```shell
brew install ariga/tap/atlas
```
Download latest release.
```shell
curl -LO https://release.ariga.io/atlas/atlas-darwin-amd64-latest
```
Make the atlas binary executable.
```shell
chmod +x ./atlas-darwin-amd64-latest
```
Move the atlas binary to a file location on your system PATH.
```shell
sudo mv ./atlas-darwin-amd64-latest /usr/local/bin/atlas
```
```shell
sudo chown root: /usr/local/bin/atlas
```
Download latest release.
```shell
curl -LO https://release.ariga.io/atlas/atlas-linux-amd64-latest
```
Move the atlas binary to a file location on your system PATH.
```shell
sudo install -o root -g root -m 0755 ./atlas-linux-amd64-latest /usr/local/bin/atlas
```
Download the [latest release](https://release.ariga.io/atlas/atlas-windows-amd64-latest.exe) and
move the atlas binary to a file location on your system PATH.
The binaries distributed in official releases are released under the [Ariga End User License](https://ariga.io/legal/atlas/eula).
If you would like to build Atlas from source follow the instructions [here](https://atlasgo.io/cli-reference#building-from-source).
### Start a local database container
For the purpose of this guide, we will start a local Docker container running MySQL.
```shell
docker run --name atlas-db -p 3306:3306 -e MYSQL_ROOT_PASSWORD=pass -e MYSQL_DATABASE=example mysql
```
For this example, we will start off with the following database:
```sql
CREATE table users (
id int PRIMARY KEY,
name varchar(100)
);
```
Our schema represents a `users` table, where each user has an ID and a name.
### Inspecting our database
Atlas features a Data Definition Language (DDL) that has an [HCL-syntax](https://github.com/hashicorp/hcl)
for defining the desired state of database schemas.
Inspection is done via the `atlas schema inspect` command.
To inspect our locally-running MySQL instance, use the `-u` flag and write the output to a file named `schema.hcl`:
```shell
atlas schema inspect -u "mysql://root:pass@localhost:3306/example" > schema.hcl
```
Open the `schema.hcl` file to view the Atlas schema that describes our database.
```hcl
table "users" {
schema = schema.example
column "id" {
null = false
type = int
}
column "name" {
null = true
type = varchar(100)
}
primary_key {
columns = [column.id]
}
}
```
This block represents a [table](../atlas-schema/sql.mdx#table) resource with `id`, and `name`
columns. The `schema` field references the `example` schema that is defined elsewhere
in this document. In addition, the `primary_key` sub-block defines the `id` column as
the primary key for the table. Atlas strives to mimic the syntax of the database that the user is working against. In this case, the
type for the `id` column is `int`, and `varchar(100)` for the `name` column.
Now, consider we want to add a `blog_posts` table and have our schema represent a simplified
blogging system.
Let's add the following to `schema.hcl`:
```hcl
table "blog_posts" {
schema = schema.example
column "id" {
null = false
type = int
}
column "title" {
null = true
type = varchar(100)
}
column "body" {
null = true
type = text
}
column "author_id" {
null = true
type = int
}
primary_key {
columns = [column.id]
}
foreign_key "author_fk" {
columns = [column.author_id]
ref_columns = [table.users.column.id]
}
index "author_id" {
unique = false
columns = [column.author_id]
}
}
```
In addition to the elements we saw in the `users` table, here we can find a [foreign key](../atlas-schema/sql.mdx#foreign-key)
block, declaring that the `author_id` column references the `id` column on the
`users` table.
Now, let's apply these changes by running a migration.
In Atlas, migrations can be applied in two types of workflows: _declarative_ and _versioned_.
### Declarative Migrations
The declarative approach requires the user to define the _desired_ end schema, and Atlas provides
a safe way to alter the database to get there.
Let's see this in action.
Continuing the example, in order to apply the changes to our database we will run the `apply` command:
```shell
atlas schema apply \
-u "mysql://root:pass@localhost:3306/example" \
-f schema.hcl
```
Atlas presents the plan it created by displaying the SQL statements. For example, for a MySQL database we will see
the following:
```console
-- Planned Changes:
-- Create "blog_posts" table
// highlight-next-line-info
CREATE TABLE `example`.`blog_posts` (`id` int NOT NULL, `title` varchar(100) NULL, `body` text NULL, `author_id` int NULL, PRIMARY KEY (`id`), INDEX `author_id` (`author_id`), CONSTRAINT `author_fk` FOREIGN KEY (`author_id`) REFERENCES `example`.`users` (`id`))
Use the arrow keys to navigate: ↓ ↑ → ←
? Are you sure?:
▸ Apply
Abort
```
Apply the changes, and that's it! You have successfully run a declarative migration.
You can reinspect the database by running the `inspect` command again to ensure that the changes have been made to the
schema.
### Versioned Migrations
Alternatively, the versioned migration workflow, sometimes called "change-based migrations", allows each change to the
database schema to be checked into source control and reviewed during code-review. Users can still benefit from Atlas
intelligently planning migrations for them, however they are not automatically applied.
To start, we will calculate the difference between the _desired_ and _current_ state of the database by running the `atlas
migrate diff` command.
To run this command, we need to provide the necessary parameters:
* `--dir` the URL to the migration directory, by default it is `file://migrations`.
* `--to` the URL of the desired state, an HCL file or a database connection.
* `--dev-url` a URL to a [Dev Database](/concepts/dev-database) that will be used to compute the diff.
```shell
atlas migrate diff create_blog_posts \
--dir="file://migrations" \
--to="file://schema.hcl" \
--dev-url="mysql://root:pass@:3306/test"
```
Run `ls migrations`, and you will notice that Atlas has created two files:
```sql
-- create "blog_posts" table
CREATE TABLE `example`.`blog_posts` (`id` int NOT NULL, `title` varchar(100) NULL, `body` text NULL, `author_id` int NULL, PRIMARY KEY (`id`), INDEX `author_id` (`author_id`), CONSTRAINT `author_fk` FOREIGN KEY (`author_id`) REFERENCES `example`.`users` (`id`))
```
In addition to the migration directory, Atlas maintains a file name `atlas.sum` which is used
to ensure the integrity of the migration directory and force developers to deal with situations
where migration order or contents was modified after the fact.
```text
h1:t1fEP1rSsGf1gYrYCjsGyEyuM0cnhATlq93B7h8uXxY=
20220811074144_create_blog_posts.sql h1:liZcCBbAn/HyBTqBAEVar9fJNKPTb2Eq+rEKZeCFC9M=
```
Now that we have our migration files ready, you can use your favorite migration tool to apply the changes generated by
Atlas.
### Next Steps
In this short tutorial we learned how to use Atlas to inspect databases, as well as use declarative and versioned
migrations. Read more about the use-cases for the two approaches [here](/concepts/declarative-vs-versioned) to help you
decide which workflow works best for you.
:::info Need help getting started?
We have a super friendly [#getting-started](https://discord.gg/8mvDUG22) channel on our community
chat on Discord.
For web-based, free, and fun (GIFs included) support:
Join our Discord server
::: atlas-0.7.2/doc/md/guides/ 0000775 0000000 0000000 00000000000 14314555116 0015256 5 ustar 00root root 0000000 0000000 atlas-0.7.2/doc/md/guides/ddl.md 0000664 0000000 0000000 00000014275 14314555116 0016354 0 ustar 00root root 0000000 0000000 ---
id: ddl
slug: /guides/ddl
title: Data Definition Language
---
## Introduction
In the core of the Atlas project resides the Atlas Data Definition Language (DDL). The DDL is designed to capture an
organization's data topologies and other aspects of its data infrastructure.
In the design of the DDL, we put an emphasis on extensibility: As data topologies can contain a set of diverse
data technologies, the language is designed to be modular with different extensions extending the types of
resources and relationships that can be described using it.
## HCL
The Atlas DDL currently supports an HCL syntax we call Atlas HCL. It is similar to other HCL based languages such as
Terraform.
### Resources
Documents written in the Atlas DDL usually describe _resources_. Resources are described as HCL blocks and have a type,
and optionally a name. Consider this block:
```hcl
user "rotemtam" {
// ...
}
```
This block describes a resource of type `user` with a name of `rotemtam`.
### Qualifiers
In some cases, a document may contain multiple resources with the same name. To differentiate between
the different resources, the Atlas DDL supports _qualifiers_, an additional label preceding the resource
name:
```hcl
person "dr" "jekyll" {
}
```
This block describes a resource of type `person`, with a name of "jekyll" which is qualified by
"dr".
### Attributes
Resources can have named attributes with primitive types (string, boolean, integer or float)
or lists of primitive values.
For example:
```hcl
user "rotemtam" {
email = "rotem@atlasgo.io"
active = true
credits = 42
tags = [
"data",
"infrastructure",
"hcl"
]
}
```
### Children
Resources can have child resources. For example:
```hcl
user "rotemtam" {
..
project "atlas" {
started = 2021
metadata {
category = "data"
}
}
}
```
### References
Attributes can hold references to other resources. The address of any resource is
`.`, recursively. Suppose we have this block describing some HTTP service:
```hcl
service "todolist" {
port "http" {
number = 8080
}
}
```
If we want to reference the child "port" resource of the service we can use
`service.todolist.port.http`:
```hcl
server "production" {
endpoint "todo" {
path = "/todo"
service_port = service.todolist.port.http
}
}
```
Attributes can hold references to other attributes. When a document is parsed the reference is replaced with the
referenced value. The address of any attribute is `..`.
```hcl
group "seinfeld" {
id = 1
}
show "friends" {
id = 2
}
playlist "comedy" {
show_ids = [
show.seinfeld.id
// will equal 1
show.friends.id,
// will equal 2
]
}
```
### Reading with Go
To read an Atlas HCL document with Go use the `EvalBytes` ([doc](https://pkg.go.dev/ariga.io/atlas/schemahcl#EvalBytes)) function
from the `schemahcl` package:
```go
func ExampleUnmarshal() {
f := `
show "seinfeld" {
writer "jerry" {
full_name = "Jerry Seinfeld"
}
writer "larry" {
full_name = "Larry David"
}
}`
type (
Writer struct {
ID string `spec:",name"`
FullName string `spec:"full_name"`
}
Show struct {
Name string `spec:",name"`
Writers []*Writer `spec:"writer"`
}
)
var test struct {
Shows []*Show `spec:"show"`
}
err := EvalBytes([]byte(f), &test, nil)
if err != nil {
panic(err)
}
seinfeld := test.Shows[0]
fmt.Printf("the show %q has %d writers.", seinfeld.Name, len(seinfeld.Writers))
// Output: the show "seinfeld" has 2 writers.
}
```
This function takes a byte-slice, an empty interface as arguments and a map of strings as input.
The empty interface should be a pointer to a struct into which the `EvalBytes` function will
read the values. The struct fields must be annotated with `spec` tags that define the mapping from HCL to the Go type.
This mapping is discussed in the section about [Extensions](#extensions). The final map argument may contain
[Input Values](/atlas-schema/input.md) to be passed as parameters of the evaluation.
### Writing with Go
To encode a Go struct back into HCL, use the `schemahcl.Marshal`
([doc](https://pkg.go.dev/ariga.io/atlas/schemahcl#Marshal)) function:
```go
func ExampleMarshal() {
type (
Point struct {
ID string `spec:",name"`
X int `spec:"x"`
Y int `spec:"y"`
}
)
var test = struct {
Points []*Point `spec:"point"`
}{
Points: []*Point{
{ID: "start", X: 0, Y: 0},
{ID: "end", X: 1, Y: 1},
},
}
b, err := Marshal(&test)
if err != nil {
panic(err)
}
fmt.Println(string(b))
// Output: point "start" {
// x = 0
// y = 0
// }
// point "end" {
// x = 1
// y = 1
// }
}
```
## Extensions
Applications working with the Atlas DDL are expected to extend the Atlas language by
defining their own type structs that objects can be handled in a type-safe way.
The mapping between the extension struct fields and the configuration syntax is done by placing tags on the
extension struct field using the `spec` key in the tag. To specify that a field should be mapped to
the corresponding resource's name specify ",name" to the tag value. For example,
```go
type Point struct {
ID string `spec:",name"`
X int `spec:"x"`
Y int `spec:"y"`
}
```
Would be able to capture a Resource defined in Atlas HCL as:
```hcl
point "origin" {
x = 100
y = 200
}
```
To operate correctly, struct extensions should be registered using the `schemahcl.Register`
function:
```go
schemahcl.Register("point", &Point{})
```
Extension structs may implement the [Remainer](https://pkg.go.dev/ariga.io/atlas/schemahcl#Remainer)
interface if they wish to store any attributes and children that are not matched by their
tagged fields. As a convenience the `schemahcl` package exports a `DefaultExtension` type that
can be embedded to support this behavior.
### Qualifiers
In cases where resources may need to be qualified, a field of the target struct can be annotated
with the `,qualifier` tag. For instance this struct:
```go
type Person struct {
Name string `spec:",name"`
Title string `spec:",qualifier"`
}
```
Can capture a qualified HCL resource such as:
```hcl
person "dr" "jekyll" {
}
```
atlas-0.7.2/doc/md/guides/guides.md 0000664 0000000 0000000 00000000536 14314555116 0017064 0 ustar 00root root 0000000 0000000 ---
title: Guides
id: guides
slug: /guides
---
# Guides
Welcome to the Atlas Guides.
## Databases
### MySQL
[Generated Columns](mysql/generated-columns.md)
### PostgreSQL
[Serial Type Columns](postgres/serial-columns.md)
[Partial Indexes](postgres/partial-indexes.md)
## Migration tools
[`golang-migrate`](migration-tools/golang-migrate.md) atlas-0.7.2/doc/md/guides/migration-tools/ 0000775 0000000 0000000 00000000000 14314555116 0020405 5 ustar 00root root 0000000 0000000 atlas-0.7.2/doc/md/guides/migration-tools/golang-migrate.md 0000664 0000000 0000000 00000017413 14314555116 0023632 0 ustar 00root root 0000000 0000000 ---
id: golang-migrate
title: Automatic migration planning for golang-migrate
slug: /guides/migration-tools/golang-migrate
---
## TL;DR
* [`golang-migrate`](https://github.com/golang-migrate/migrate) is a popular database migration
CLI tool and Go library that's widely used in the Go community.
* [Atlas](https://atlasgo.io) is an open-source tool for inspecting, planning, linting and
executing schema changes to your database.
* Developers using `golang-migrate` can use Atlas to automatically plan schema migrations
for them, based on the desired state of their schema instead of crafting them by hand.
## Automatic migration planning for golang-migrate
Atlas can automatically plan database schema migrations for developers using `golang-migrate`.
Atlas plans migrations by calculating the diff between the _current_ state of the database,
and it's _desired_ state.
For golang-migrate users, the current state can be thought of as the sum of
all _up_ migrations in a migration directory. The desired state can be provided to Atlas
via an Atlas schema [HCL file](https://atlasgo.io/atlas-schema/sql-resources) or as a
connection string to a database that contains the desired schema.
In this guide, we will show how Atlas can automatically plan schema migrations for
golang-migrate users.
## Prerequisites
* An existing project with a `golang-migrate` migrations directory.
* Docker
* Atlas ([installation guide](https://atlasgo.io/getting-started/#installation))
## Dev database
To plan a migration from the current to the desired state, Atlas uses a [Dev Database](/concepts/dev-database),
which is usually provided by a locally running container with an empty database of the type
you work with (such as MySQL or PostgreSQL).
To spin up a local MySQL database that will be used as a dev-database in our example, run:
```text
docker run --rm --name atlas-db-dev -d -p 3306:3306 -e MYSQL_DATABASE=dev -e MYSQL_ROOT_PASSWORD=pass mysql:8
```
As reference for the next steps, the URL for the Dev Database will be:
```text
mysql://root:pass@localhost:3306/dev
```
## Migration directory integrity
To ensure migration history is correct while multiple developers work on the same project
in parallel Atlas enforces [migration directory integrity](/concepts/migration-directory-integrity)
using a file name `atlas.sum`.
For this example, we will assume your migrations are stored in a directory named `migrations`
in your current working directory:
To generate this file run:
```text
atlas migrate hash --dir file://migrations
```
Observe a new file named `atlas.sum` was created in your migrations directory
which contains a hash sum of each file in your directory as well as a total sum.
For example:
```text
h1:y6Zf8kAu98N0jAR+yemZ7zT91nUyECLWzxxR7GHJIAg=
1_init.down.sql h1:0zpQpoUZcacEatOD+DYXgYD1XvfWUC7EM+agXIRzKRU=
1_init.up.sql h1:kOM+4u8UsYvvjQMFYAo2hDv5rbx3Mdbh9GvhmbpS0Ig=
```
## Convert you migrations directory to an Atlas schema file
With Atlas, users can describe their desired schema using an [HCL-based configuration language](https://atlasgo.io/atlas-schema/sql-resources).
As a new user coming from an existing project, you may not want to learn this new language and
prefer that Atlas will generate a schema file that reflects your existing schema.
:::info
If you want to read the desired state from a database instead of an Atlas HCL schema file,
have a look [here](/guides/migration-tools/golang-migrate#alternative-use-an-existing-database-as-the-desired-state).
:::
Let's see how you can get your current schema from `golang-migrate` to the Atlas schema format.
1\. Open a MySQL shell inside our running container:
```text
docker exec -it atlas-db-dev mysql -ppass
```
2\. Create a new database named `migrate-current`:
```text
CREATE DATABASE `migrate-current`
```
The database is created successfully:
```text
Query OK, 1 row affected (0.01 sec)
```
3\. Close the shell and run `golang-migrate` to run all migrations on our new database:
```text
migrate -source file://migrations -database 'mysql://root:pass@tcp(localhost:3306)/migrate-current' up
```
All migrations are executed successfully:
```text
1/u init (35.601678ms)
```
4\. Next, use Atlas's `schema inspect` command to write a file named `schema.hcl` with an HCL
representation of your migration directory. Notice that we exclude the `schema_migrations` table
which contains `golang-migrate`'s revision history.
```text
atlas schema inspect -u mysql://root:pass@localhost:3306/migrate-current --exclude '*.schema_migrations' > schema.hcl
```
Observe that a new file named `schema.hcl` was created:
```hcl
table "users" {
schema = schema.migrate-current
column "id" {
null = false
type = int
}
column "name" {
null = true
type = varchar(100)
}
primary_key {
columns = [column.id]
}
}
schema "migrate-current" {
charset = "utf8mb4"
collate = "utf8mb4_0900_ai_ci"
}
```
## Plan a new migration
Next, let's modify the desired state of our database by modifying the `schema.hcl` file
to add a new table `blog_posts` that has a foreign key pointing to the existing `users`
table:
```hcl
table "blog_posts" {
schema = schema.migrate-current
column "id" {
type = int
}
column "title" {
type = varchar(255)
}
column "body" {
type = text
}
column "author_id" {
type = int
}
foreign_key "blog_author_fk" {
columns = [column.author_id]
ref_columns = [table.users.column.id]
}
}
```
Now, let's use Atlas's `migrate diff` command to plan a migration from the current state
as it exists in the migrations directory to the desired state that is defined by the `schema.hcl`
file:
```text
atlas migrate diff --dir file://migrations --dev-url mysql://root:pass@localhost:3306/dev --to file://schema.hcl --dir-format golang-migrate add_blog_posts
```
Notice that we used the `dir-format` flag to specify that we're using `golang-migrate` as the directory format.
Hooray! Two new files were created in the migrations directory:
```text {5-6}
.
├── migrations
│ ├── 1_init.down.sql
│ ├── 1_init.up.sql
│ ├── 20220922123326_add_blog_posts.down.sql
│ ├── 20220922123326_add_blog_posts.up.sql
│ └── atlas.sum
└── schema.hcl
```
An up migration:
```sql
-- create "blog_posts" table
CREATE TABLE `blog_posts` (`id` int NOT NULL, `title` varchar(255) NOT NULL, `body` text NOT NULL, `author_id` int NOT NULL, INDEX `blog_author_fk` (`author_id`), CONSTRAINT `blog_author_fk` FOREIGN KEY (`author_id`) REFERENCES `users` (`id`) ON UPDATE NO ACTION ON DELETE NO ACTION) CHARSET utf8mb4 COLLATE utf8mb4_0900_ai_ci;
```
And a down migration:
```sql
-- reverse: create "blog_posts" table
DROP TABLE `blog_posts`;
```
## Alternative: use an existing database as the desired state
In some cases, it is convenient to use the schema of an existing database as the desired
state for your project, instead of defining it in HCL. Atlas's `migrate diff` command can
plan a migration from your current migration directory state to an existing schema. Suppose such a
database was available at `mysql://root:pass@some.db.io:3306/db`, a migration to the state
of that database could be planned by running:
```text
atlas migrate diff --dir file://migrations --dev-url mysql://root:pass@localhost:3306/dev --to mysql://root:pass@some.db.io:3306/db --dir-format golang-migrate migration_name
```
## Conclusion
We began our demo by explaining how to set up a dev-database and `atlas.sum` file for your project.
Next, we showed how to use Atlas's `schema inspect` command to extract the current desired
schema of your project from an existing migration directory. Finally, we showed how to
automatically plan a schema migration by modifying the desired schema definition
and using Atlas's `migrate diff` command.
Have questions? Feedback? Find our team [on our Discord server](https://discord.gg/zZ6sWVg6NT).
atlas-0.7.2/doc/md/guides/mysql/ 0000775 0000000 0000000 00000000000 14314555116 0016423 5 ustar 00root root 0000000 0000000 atlas-0.7.2/doc/md/guides/mysql/generated-columns.md 0000664 0000000 0000000 00000021360 14314555116 0022363 0 ustar 00root root 0000000 0000000 ---
id: generated-columns
title: Generated Columns in MySQL with Atlas
slug: /guides/mysql/generated-columns
---
**MySQL** is a popular open-source relational database. **Generated columns** are a feature of MySQL that allows you to
define tables with columns whose value is a function of the value stored in other columns; without requiring complex
expressions in `SELECT`, `INSERT` or `UPDATE` queries.
## What are Generated Columns?
Generated columns are columns that contain values calculated by expressions which can be dependent on other columns; in
a similar manner to formulas in a spreadsheet. There are two types of generated columns in MySQL: _Stored_ and _Virtual_.
### Stored Generated Columns
Stored generated columns are stored and evaluated when a row is inserted or updated. As a result, stored generated
columns use disk space in addition to CPU cycles during the execution of `INSERT` and `UPDATE` statements.
### Virtual Generated Columns
Virtual generated columns are not stored, and only evaluated when a row is read
_(after BEFORE [triggers](https://dev.mysql.com/doc/refman/5.7/en/trigger-syntax.html))_.
As a result, virtual generated columns take no storage at the cost of CPU cycles for `SELECT` statements.
### Limitations of Generated Columns
Generated column expressions must be deterministic which means that — given the same input — an expression must always
produce the same output. As a result, generated columns can not be used with stored variables, functions, procedures,
and subqueries; which could cause the output to be non-deterministic. Following this constraint, generated columns can
not be used to generate random values. On the other hand, a generated column may reference any non-generated
column _regardless_ of its position within the table row and any other generated column within the same table row,
as long as those columns are declared before the generated column.
## When to use Generated Columns?
Generated columns should be used whenever you want to create a column with a value that can be directly determined
from the values of other columns in the same row. In simpler words, for data that is dependent on other data. This
saves the developer from complex application code that is prone to errors on `SELECT`, `INSERT` and `UPDATE` statements.
It also ensures that data which must be consistent, stays consistent.
**MySQL Syntax for a Generated Column**
```sql
column_name data_type [GENERATED ALWAYS] AS (expr) [VIRTUAL | STORED]
[NOT NULL | NULL] [UNIQUE [KEY]] [[PRIMARY] KEY] [COMMENT 'string']
```
### Using Stored Generated Columns
Stored generated columns should be used for data _(in a table)_ that is read more frequently than it is updated.
This saves CPU cycles while reading rows _(via `SELECT`)_. Stored generated columns should also be used when you
want to use the column in the table primary key or use it as a foreign key constraint. Alternatively, use stored
generated columns as a cache for complex conditions that are costly to calculate.
#### Example
The following example declares a stored generated column in a table that stores the base and height of a triangle in the `base` and `height` column, then computes its area in `area` _(when triangles are inserted or updated)_.
```sql
CREATE TABLE triangles (
base DOUBLE,
height DOUBLE,
area DOUBLE AS (base * height * 1/2) STORED
);
```
### Using Virtual Generated Columns
Virtual generated columns should be used for computed data _(in a table)_ that is updated more frequently than it is read or computed data that is expensive to store on disk _(via `INSERT` or `UPDATE`)_. Since values are calculated on the fly, virtual generated columns are perfect for table columns that will have a new value for every `SELECT` statement. If you use the _InnoDB Storage Engine_, secondary indexes can be defined on virtual columns.
#### Example
The following example declares a virtual generated column in a table that stores the price and amount of products sold in the `price` and `quantity` column, then computes its `revenue` _(when products are read)_.
```sql
CREATE TABLE products (
price DOUBLE,
quantity INT,
revenue DOUBLE AS (price * quantity) VIRTUAL
);
```
## Managing Generated Columns is easy with Atlas
Managing generated columns and database schemas in MySQL is confusing and error-prone. [Atlas](https://atlasgo.io) is an open-source tool that allows you to manage your database using a simple declarative syntax (similar to Terraform). Instead of creating complex SQL statements that break upon schema migration, we will implement generated columns using Atlas.
### Getting started with Atlas
Install the latest version of Atlas using the [Guide to Setting Up Atlas](/cli/getting-started/setting-up).
### Generated Column Syntax in Atlas
Use `as` in a column in a table to declare a MySQL generated column. For examples with other databases, read the [Atlas Generated Columns DDL](/atlas-schema/sql.mdx#generated-columns).
```hcl
column "name" {
type = data_type
as {
expr = expression
type = [STORED | VIRTUAL]
}
}
```
### Implementing Stored Generated Columns with Atlas
The following example declares a stored generated column in a table that stores the lengths of the sides of right-triangles in the `a` and `b` column, then computes the hypotenuse in `c` _(when triangles are inserted or updated)_.
```hcl
table "triangles" {
schema = schema.example
column "a" {
type = numeric
}
column "b" {
type = numeric
}
column "hypotenuse" {
type = numeric
as {
expr = "SQRT(a * a + b * b)"
type = STORED
}
}
}
```
Guarantee the table is created by applying the schema to the database.
```
atlas schema apply -u "mysql://root:pass@localhost:3306/example" -f atlas.hcl
```
Approve the schema migration plan that Atlas creates for you _(if applicable)_.
```
-- Planned Changes:
-- Create "triangles" table
CREATE TABLE "example"."triangles" ("a" numeric NOT NULL, "b" numeric NOT NULL, "hypotenuse" numeric NOT NULL GENERATED ALWAYS AS (SQRT(a * a + b * b)) STORED)
Use the arrow keys to navigate: ↓ ↑ → ←
? Are you sure?:
> Apply
Abort
```
Insert triangles into the table.
```sql
INSERT INTO triangles (a, b) VALUES (1,1);
INSERT INTO triangles (a, b) VALUES (3,4);
INSERT INTO triangles (a, b) VALUES (6,8);
```
Select all the triangles in the table using `SELECT * FROM triangles` to receive a table with the following output.
| a | b | c |
| :--- | :--- | :----------------- |
| 1 | 1 | 1.4142135623730951 |
| 3 | 4 | 5 |
| 6 | 8 | 10 |
### Implementing Virtual Generated Columns Columns with Atlas
The following example declares a virtual generated column in a TABLE that stores the first and last name of a person, and computes the full name of the person _(when people are selected)_.
```hcl
table "people" {
schema = schema.example
column "first_name" {
type = varchar(255)
}
column "last_name" {
type = varchar(255)
}
column "full_name" {
type = varchar(255)
as {
expr = "first_name + ' ' + last_name"
type = VIRTUAL
}
}
}
```
Alternatively, use the default type of generated column _(VIRTUAL in MySQL)_.
```hcl
table "people" {
schema = schema.example
column "first_name" {
type = varchar(255)
}
column "last_name" {
type = varchar(255)
}
column "full_name" {
type = varchar(255)
as = "first_name + ' ' + last_name"
}
}
```
Approve the schema migration plan that Atlas creates for you _(if applicable)_.
```
-- Planned Changes:
-- Create "people" table
CREATE TABLE "example"."people" ("first_name" character varying(255) NOT NULL, "last_name" character varying(255) NOT NULL, "full_name" character varying(255) NOT NULL GENERATED ALWAYS AS (first_name + ' ' + last_name) VIRTUAL)
Use the arrow keys to navigate: ↓ ↑ → ←
? Are you sure?:
> Apply
Abort
```
Insert people into the table.
```sql
INSERT INTO people (first_name, last_name) VALUES ("Bob", "Bark");
INSERT INTO people (first_name, last_name) VALUES ("Kat", "Meow");
INSERT INTO people (first_name, last_name) VALUES ("Ty", "Garoar");
```
Select all the people in the table using `SELECT * FROM people` to receive a table with the following output.
| first_name | last_name | full_name |
| :--------- | :-------- | :-------- |
| Bob | Bark | Bob Bark |
| Kat | Meow | Kat Meow |
| Ty | Garoar | Ty Garoar |
## Need More Help?
[Join the Ariga Discord Server](https://discord.gg/zZ6sWVg6NT) for early access to features and the ability to provide
exclusive feedback that improves your Database Management Tooling.
atlas-0.7.2/doc/md/guides/postgres/ 0000775 0000000 0000000 00000000000 14314555116 0017124 5 ustar 00root root 0000000 0000000 atlas-0.7.2/doc/md/guides/postgres/partial-indexes.md 0000664 0000000 0000000 00000027305 14314555116 0022546 0 ustar 00root root 0000000 0000000 ---
id: partial-indexes
title: Partial Indexes in PostgreSQL
slug: /guides/postgres/partial-indexes
---
### Overview of Partial Indexes
#### What are Partial Indexes?
With PostgreSQL, users may create _partial indexes_, which are types of indexes that exist on a subset of a table, rather than the entire table itself. If used correctly, partial indexes improve performance and reduce costs, all while minimizing the amount of storage space they take up on the disk.
#### Why do we need them?
Let's demonstrate a case where partial indexes may be useful by contrasting them with a non-partial index. If you have many records in an indexed table, the number of records the index needs to track also grows. If the index grows in size, the disk space needed to store the index itself increases as well.
In many tables, different records are not accessed with uniform frequency. A subset of a table's records might not be searched very frequently or not searched at all. Records take up precious space in your index whether they are queried or not, and are updated when a new entry is added to the field.
Partial indexes come into the picture to filter unsearched values and give you, as an engineer, a tool to index only what's important.
:::info
You can learn more about partial indexes in PostgreSQL [here](https://www.postgresql.org/docs/current/indexes-partial.html)
:::
#### Advantages of using Partial Indexes
In cases where we know ahead of time the access pattern to a table and can reduce the size of an index by making it partial:
1. Response time for SELECT operations is improved because the database searches through a smaller index.
2. On average, response time for UPDATE operations is also improved as the index is not going to get updated in all cases.
3. Index is smaller in size and can fit into RAM more easily. s
4. Less space is required to store the index on disk.
#### Basic PostgreSQL syntax for using Partial Index
```sql
CREATE INDEX
index_name
ON
table_name(column_list)
WHERE
condition;
```
#### Example of Non-partial Index vs Partial Index in PostgreSQL
Let's see this in action by creating a table with the following command:
```sql
CREATE TABLE "vaccination_data" (
id SERIAL PRIMARY KEY,
country varchar(20),
title varchar(10),
names varchar(20),
vaccinated varchar(3)
);
```
Here is how a portion of the table might look like after inserting values:
```sql
SELECT * FROM vaccination_data;
```
```console title="Output"
id | country | title | names | vaccinated
-----+--------------------+-------+-------------+------------
1 | Poland | Mr. | Teagan | No
2 | Ukraine | Ms. | Alden | No
3 | Ukraine | Mr. | Ima | No
4 | Colombia | Mr. | Lawrence | Yes
5 | Turkey | Mrs. | Keegan | No
6 | China | Mrs. | Kylan | No
7 | Netherlands | Dr. | Howard | No
...
289690 | Russian Federation | Mrs. | Ray | Yes
289689 | Austria | Dr. | Lenore | Yes
289688 | Sweden | Dr. | Walker | Yes
289687 | Turkey | Dr. | Emerson | No
289686 | Vietnam | Dr. | Addison | Yes
(289686 rows)
```
In the following example, suppose we want a list of doctors from India that have taken the vaccine. If we want to use normal index, we can create it on the “vaccinated” column with the following command:
```sql
CREATE INDEX vaccinated_idx ON vaccination_data(vaccinated);
```
```console title="Output"
CREATE INDEX
Time: 333.891 ms
```
Now, let's check the performance of querying data of doctors from India that have taken the vaccine with the following command:
```sql
EXPLAIN ANALYZE
SELECT
*
FROM
vaccination_data
WHERE
vaccinated = 'Yes' AND country = 'India' AND title = 'Dr.';
```
```console title="Output"
QUERY PLAN
---------------------------------------------------------------------------
Bitmap Heap Scan on vaccination_data (cost=758.64..4053.40 rows=699 width=25) (actual time=4.142..16.212 rows=582 loops=1)
Recheck Cond: ((vaccinated)::text = 'Yes'::text)
Filter: (((country)::text = 'India'::text) AND ((title)::text = 'Dr.'::text))
Rows Removed by Filter: 69334
Heap Blocks: exact=1337
-> Bitmap Index Scan on vaccinated_idx (cost=0.00..758.46 rows=69072 width=0) (actual time=3.940
..3.941 rows=69916 loops=1)
Index Cond: ((vaccinated)::text = 'Yes'::text)
Planning Time: 0.188 ms
Execution Time: 16.292 ms
(9 rows)
```
:::info
The EXPLAIN command is used for understanding the performance of a query. You can learn more about usage of EXPLAIN command with ANALYZE option [here](https://www.postgresql.org/docs/14/using-explain.html#USING-EXPLAIN-ANALYZE)
:::
Notice that total Execution Time is 16.292ms. Also, let's check the index size with the following command:
```sql
SELECT pg_size_pretty(pg_relation_size('vaccinated_idx'));
```
```console title="Output"
pg_size_pretty
----------------
1984 kB
(1 row)
```
Now, suppose we want to accelerate the same query using the partial index. Let's begin by dropping the existing index that we created earlier:
```sql
DROP INDEX vaccinated_idx;
```
```console title="Output"
DROP INDEX
Time: 7.183 ms
```
In the following command, we have created an index with a WHERE clause that precisely describes list of doctors from India that have taken the vaccine.
```sql
CREATE INDEX
vaccinated_idx
ON
vaccination_data(vaccinated)
WHERE
vaccinated = 'Yes' AND country = 'India' AND title = 'Dr.';
```
```console title="Output"
CREATE INDEX
Time: 94.567 ms
```
Notice that the partial index with the WHERE clause is created in 94.567ms, compared to the 333.891ms taken for the non-partial index on the 'vaccinated' column.
Let's check the performance of querying list of doctors from India that have taken the vaccine again, using the following command:
```sql
EXPLAIN ANALYZE
SELECT
*
FROM
vaccination_data
WHERE
vaccinated = 'Yes' AND country = 'India' AND title = 'Dr.';
```
```console title="Output"
QUERY PLAN
---------------------------------------------------------------------------
Index Scan using vaccinated_idx on vaccination_data (cost=0.15..1455.12 rows=699 width=25) (actual time=0.015..0.704 rows=582 loops=1)
Planning Time: 0.442 ms
Execution Time: 0.880 ms
(3 rows)
```
Observe that total execution time has dropped significantly and is now only 0.880ms, compared to 16.292ms achieved by using a non-partial index on the 'vaccinated' column. Once again, let's check the index size with the following command:
```sql
SELECT pg_size_pretty(pg_relation_size('vaccinated_idx'));
```
```console title="Output"
pg_size_pretty
----------------
16 kB
(1 row)
```
As we can observe, the index size for the partial index takes significantly less space (16kb) compared to the non-partial index that we created earlier on the 'vaccinated' column (1984kb).
Here is a summary from our tests:
| Parameter | Non-partial Index | Partial Index | Ratio of change(%) |
|:-------------------------------------------- |:----------------------- |:----------------------- |:------------------ |
| Estimated start-up cost | 758.64 arbitrary units | 0.15 arbitrary units | 99.9% reduced cost |
| Estimated total cost | 4053.40 arbitrary units | 1455.12 arbitrary units | 64.1% reduced cost |
| Time to create index | 333.891ms | 94.567ms | 71.6% less time |
| Execution time for query with “WHERE” clause | 16.292ms | 0.880ms | 94.5% less time |
| Size of index | 1984kb | 16kb | 99.1% less space |
(Note: The results will vary, depending on the data that is stored in the database)
We have seen that creating a partial index is a better choice where only a small subset of the values stored in the database are accessed frequently. Now, let's see how we can easily manage partial indexes using Atlas.
### Managing Partial Indexes is easy with Atlas
Managing partial indexes and database schemas in PostgreSQL can be confusing and error-prone. Atlas is an open-source project which allows us to manage our database using a simple and easy-to-understand declarative syntax (similar to Terraform). We will now learn how to manage partial indexes using Atlas.
:::info
If you are just getting started, install the latest version of Atlas using the guide to [setting up Atlas](https://atlasgo.io/cli/getting-started/setting-up).
:::
#### Managing Partial Index in Atlas
We will first use the `atlas schema inspect` command to get an HCL representation of the table which we created earlier by using the Atlas CLI:
```console
atlas schema inspect -u "postgres://postgres:mysecretpassword@localhost:5432/vaccination_data?sslmode=disable" > schema.hcl
```
```hcl title="schema.hcl"
table "vaccination_data" {
schema = schema.public
column "id" {
null = false
type = serial
}
column "country" {
null = true
type = character_varying(20)
}
column "title" {
null = true
type = character_varying(10)
}
column "names" {
null = true
type = character_varying(20)
}
column "vaccinated" {
null = true
type = character_varying(3)
}
primary_key {
columns = [column.id]
}
}
schema "public" {
}
```
Now, lets add the following index definition to the file:
```hcl
index "vaccinated_idx" {
columns = [column.vaccinated]
where = "(vaccinated::text = 'Yes'::text AND country::text = 'India'::text AND title::text = 'Dr.'::text)"
}
```
Save and apply the schema changes on the database by using the following command:
```console
atlas schema apply -u "postgres://postgres:mysecretpassword@localhost:5432/vaccination_data?sslmode=disable" -f schema.hcl
```
Atlas generates the necessary SQL statements to add the new partial index to the database schema. Press Enter while the `Apply` option is highlighted to apply the changes:
```console
-- Planned Changes:
-- Create index "vaccinated_idx" to table: "vaccination_data"
CREATE INDEX "vaccinated_idx" ON "public"."vaccination_data" ("vaccinated") WHERE (vaccinated::text = 'Yes'::text AND country::text = 'India'::text AND title::text = 'Dr.'::text)
✔ Apply
Abort
```
To verify that our new index was created, open the database command line tool from previous step and run:
```sql
SELECT
indexname,
indexdef
FROM
pg_indexes
WHERE
tablename = 'vaccination_data';
```
```console title="Output"
[ RECORD 1 ]
indexname | vaccinated_idx
indexdef | CREATE INDEX vaccinated_idx ON public.vaccination_data USING btree (vaccinated) WHERE (((vaccinated)::text = 'Yes'::text) AND ((country)::text = 'India'::text) AND ((title)::text = 'Dr.'::text))
```
Amazing! Our new partial index is now created!
### Limitation of using Partial Index
Partial indexes are useful in cases where we know ahead of time that a table is most frequently queried with a certain `WHERE` clause. As applications evolve, access patterns to the database also change. Consequently, we may find ourselves in a situation where our index no longer covers many queries, causing them to become resource consuming and slow.
### Conclusion
In this section, we learned about PostgreSQL partial indexes and how we can easily create partial indexes in our database by using Atlas.
## Need More Help?
[Join the Ariga Discord Server](https://discord.gg/zZ6sWVg6NT) for early access to features and the ability to provide exclusive feedback that improves your Database Management Tooling. atlas-0.7.2/doc/md/guides/postgres/serial-columns.md 0000664 0000000 0000000 00000015722 14314555116 0022412 0 ustar 00root root 0000000 0000000 ---
id: serial-columns
title: Serial Type Columns in PostgreSQL
slug: /guides/postgres/serial-columns
---
PostgreSQL allows creating columns of types `smallserial`, `serial`, and `bigserial`. These types are not
_actual_ types, but more like "macros" for creating non-nullable integer columns with sequences attached.
We can see this in action by creating a table with 3 "serial columns":
```sql
CREATE TABLE serials(
c1 smallserial,
c2 serial,
c3 bigserial
);
```
```sql title="Serials Description"
Column | Type | Nullable | Default
--------+----------+----------+-------------------------------
c1 | smallint | not null | nextval('t_c1_seq'::regclass)
c2 | integer | not null | nextval('t_c2_seq'::regclass)
c3 | bigint | not null | nextval('t_c3_seq'::regclass)
```
As you can see, each serial column was created as non-nullable integer with a default value set to the next sequence
value.
:::info
Note that `nextval` increments the sequence by 1 and returns its value. Thus, the first call to
`nextval('serials_c1_seq')` returns 1, the second returns 2, etc.
:::
### `ALTER COLUMN` type to serial
Sometimes it is necessary to change the column type from `integer` type to `serial`. However, as mentioned above, the
`serial` type is not a true type, and therefore, the following commands will fail:
```sql
CREATE TABLE t(
c integer not null primary key
);
ALTER TABLE t ALTER COLUMN c TYPE serial;
// highlight-next-line-error-message
ERROR: type "serial" does not exist
```
We can achieve this by manually creating a [sequence](https://www.postgresql.org/docs/current/sql-createsequence.html)
owned by the column `c`, and setting the column `DEFAULT` value to the incremental counter of the sequence using the
[`nextval`](https://www.postgresql.org/docs/current/functions-sequence.html) function.
:::note
Note that it is recommended to follow the PostgreSQL naming format (i.e. `
}
function AtlasButton({ link, text, type, style }) {
return (
)
}
export default function () {
return
{/* first slide */}
Manage your database schemas with Atlas CLI
Atlas CLI is an open source tool that helps developers
manage their database schemas by applying modern
DevOps principles. Contrary to existing tools, Atlas
intelligently plans schema migrations for you, based
on your desired state.
{/* 2nd slide */}
Define your schemas using the Atlas DDL
Atlas DDL is a declarative, Terraform-like configuration language designed to capture an
organization’s data topology. Currently, it supports defining schemas for SQL databases such as
MySQL, Postgres, SQLite and MariaDB.
{() => {
const mobile = window.innerWidth < 768;
const erdImage = mobile ? "https://atlasgo.io/uploads/images/erd-mobile.png" : "https://atlasgo.io/uploads/erd-180122.png";
return
}}
{/* 3rd slide*/}
Powering Ent
Atlas powers Ent, an entity framework for Go, is a Linux foundation backed project, originally developed and open sourced by Facebook in 2019. Ent uses Atlas as its migration engine, allowing Ent users to unlock safe and robust migration workflows for their applications.
{/* 4th slide */}
Migrate, your way.
Atlas provides the user with two types of migrations - declarative and versioned.
Declarative Migrations
Declarative migrations are migrations in which the user provides the desired state, and Atlas gets your schema there instantly.
Versioned Migrations
Atlas offers you an alternative workflow, in which migrations are explicitly defined and
assigned a version. Atlas can then bring a schema to the desired version by following
the migrations between the current version and the specified one.
__..._key.
// In case of conflict, PostgreSQL adds additional index at the end (e.g. "key1").
p := fmt.Sprintf("%s_%s_key", t.Name, strings.Join(names, "_"))
if idx.Name == p {
return true
}
i, err := strconv.ParseInt(strings.TrimPrefix(idx.Name, p), 10, 64)
return err == nil && i > 0
}
// IndexAttrChanged reports if the index attributes were changed.
// The default type is BTREE if no type was specified.
func (*diff) IndexAttrChanged(from, to []schema.Attr) bool {
t1 := &IndexType{T: IndexTypeBTree}
if sqlx.Has(from, t1) {
t1.T = strings.ToUpper(t1.T)
}
t2 := &IndexType{T: IndexTypeBTree}
if sqlx.Has(to, t2) {
t2.T = strings.ToUpper(t2.T)
}
if t1.T != t2.T {
return true
}
var p1, p2 IndexPredicate
if sqlx.Has(from, &p1) != sqlx.Has(to, &p2) || (p1.P != p2.P && p1.P != sqlx.MayWrap(p2.P)) {
return true
}
if indexIncludeChanged(from, to) {
return true
}
s1, ok1 := indexStorageParams(from)
s2, ok2 := indexStorageParams(to)
return ok1 != ok2 || ok1 && *s1 != *s2
}
// IndexPartAttrChanged reports if the index-part attributes were changed.
func (*diff) IndexPartAttrChanged(from, to *schema.IndexPart) bool {
p1 := &IndexColumnProperty{NullsFirst: from.Desc, NullsLast: !from.Desc}
sqlx.Has(from.Attrs, p1)
p2 := &IndexColumnProperty{NullsFirst: to.Desc, NullsLast: !to.Desc}
sqlx.Has(to.Attrs, p2)
return p1.NullsFirst != p2.NullsFirst || p1.NullsLast != p2.NullsLast
}
// ReferenceChanged reports if the foreign key referential action was changed.
func (*diff) ReferenceChanged(from, to schema.ReferenceOption) bool {
// According to PostgreSQL, the NO ACTION rule is set
// if no referential action was defined in foreign key.
if from == "" {
from = schema.NoAction
}
if to == "" {
to = schema.NoAction
}
return from != to
}
func (d *diff) typeChanged(from, to *schema.Column) (bool, error) {
fromT, toT := from.Type.Type, to.Type.Type
if fromT == nil || toT == nil {
return false, fmt.Errorf("postgres: missing type information for column %q", from.Name)
}
if reflect.TypeOf(fromT) != reflect.TypeOf(toT) {
return true, nil
}
var changed bool
switch fromT := fromT.(type) {
case *schema.BinaryType, *BitType, *schema.BoolType, *schema.DecimalType, *schema.FloatType,
*IntervalType, *schema.IntegerType, *schema.JSONType, *SerialType, *schema.SpatialType,
*schema.StringType, *schema.TimeType, *NetworkType, *UserDefinedType:
t1, err := FormatType(toT)
if err != nil {
return false, err
}
t2, err := FormatType(fromT)
if err != nil {
return false, err
}
changed = t1 != t2
case *schema.EnumType:
toT := toT.(*schema.EnumType)
// Column type was changed if the underlying enum type was changed or values are not equal.
changed = !sqlx.ValuesEqual(fromT.Values, toT.Values) || fromT.T != toT.T ||
(toT.Schema != nil && fromT.Schema != nil && fromT.Schema.Name != toT.Schema.Name)
case *CurrencyType:
toT := toT.(*CurrencyType)
changed = fromT.T != toT.T
case *UUIDType:
toT := toT.(*UUIDType)
changed = fromT.T != toT.T
case *XMLType:
toT := toT.(*XMLType)
changed = fromT.T != toT.T
case *ArrayType:
toT := toT.(*ArrayType)
// Same type.
if changed = fromT.T != toT.T; !changed {
// In case it is an enum type, compare its values.
fromE, ok1 := fromT.Type.(*schema.EnumType)
toE, ok2 := toT.Type.(*schema.EnumType)
changed = ok1 && ok2 && !sqlx.ValuesEqual(fromE.Values, toE.Values)
break
}
// In case the desired schema is not normalized, the string type can look different even
// if the two strings represent the same array type (varchar(1), character varying (1)).
// Therefore, we try by comparing the underlying types if they were defined.
if fromT.Type != nil && toT.Type != nil {
t1, err := FormatType(fromT.Type)
if err != nil {
return false, err
}
t2, err := FormatType(toT.Type)
if err != nil {
return false, err
}
// Same underlying type.
changed = t1 != t2
}
default:
return false, &sqlx.UnsupportedTypeError{Type: fromT}
}
return changed, nil
}
// valuesEqual reports if the DEFAULT values x and y
// equal according to the database engine.
func (d *diff) valuesEqual(x, y string) (bool, error) {
var b bool
// The DEFAULT expressions are safe to be inlined in the SELECT
// statement same as we inline them in the CREATE TABLE statement.
rows, err := d.QueryContext(context.Background(), fmt.Sprintf("SELECT %s = %s", x, y))
if err != nil {
return false, err
}
if err := sqlx.ScanOne(rows, &b); err != nil {
return false, err
}
return b, nil
}
// Default IDENTITY attributes.
const (
defaultIdentityGen = "BY DEFAULT"
defaultSeqStart = 1
defaultSeqIncrement = 1
)
// identityChanged reports if one of the identity attributes was changed.
func identityChanged(from, to []schema.Attr) bool {
i1, ok1 := identity(from)
i2, ok2 := identity(to)
if !ok1 && !ok2 || ok1 != ok2 {
return ok1 != ok2
}
return i1.Generation != i2.Generation || i1.Sequence.Start != i2.Sequence.Start || i1.Sequence.Increment != i2.Sequence.Increment
}
func identity(attrs []schema.Attr) (*Identity, bool) {
i := &Identity{}
if !sqlx.Has(attrs, i) {
return nil, false
}
if i.Generation == "" {
i.Generation = defaultIdentityGen
}
if i.Sequence == nil {
i.Sequence = &Sequence{Start: defaultSeqStart, Increment: defaultSeqIncrement}
return i, true
}
if i.Sequence.Start == 0 {
i.Sequence.Start = defaultSeqStart
}
if i.Sequence.Increment == 0 {
i.Sequence.Increment = defaultSeqIncrement
}
return i, true
}
// formatPartition returns the string representation of the
// partition key according to the PostgreSQL format/grammar.
func formatPartition(p Partition) (string, error) {
b := &sqlx.Builder{QuoteChar: '"'}
b.P("PARTITION BY")
switch t := strings.ToUpper(p.T); t {
case PartitionTypeRange, PartitionTypeList, PartitionTypeHash:
b.P(t)
default:
return "", fmt.Errorf("unknown partition type: %q", t)
}
if len(p.Parts) == 0 {
return "", errors.New("missing parts for partition key")
}
b.Wrap(func(b *sqlx.Builder) {
b.MapComma(p.Parts, func(i int, b *sqlx.Builder) {
switch k := p.Parts[i]; {
case k.C != nil:
b.Ident(k.C.Name)
case k.X != nil:
b.P(sqlx.MayWrap(k.X.(*schema.RawExpr).X))
}
})
})
return b.String(), nil
}
// indexStorageParams returns the index storage parameters from the attributes
// in case it is there, and it is not the default.
func indexStorageParams(attrs []schema.Attr) (*IndexStorageParams, bool) {
s := &IndexStorageParams{}
if !sqlx.Has(attrs, s) {
return nil, false
}
if !s.AutoSummarize && (s.PagesPerRange == 0 || s.PagesPerRange == defaultPagePerRange) {
return nil, false
}
return s, true
}
// indexIncludeChanged reports if the INCLUDE attribute clause was changed.
func indexIncludeChanged(from, to []schema.Attr) bool {
var fromI, toI IndexInclude
if sqlx.Has(from, &fromI) != sqlx.Has(to, &toI) || len(fromI.Columns) != len(toI.Columns) {
return true
}
for i := range fromI.Columns {
if fromI.Columns[i].Name != toI.Columns[i].Name {
return true
}
}
return false
}
func trimCast(s string) string {
i := strings.LastIndex(s, "::")
if i == -1 {
return s
}
for _, r := range s[i+2:] {
if r != ' ' && !unicode.IsLetter(r) {
return s
}
}
return s[:i]
}
atlas-0.7.2/sql/postgres/diff_test.go 0000664 0000000 0000000 00000041467 14314555116 0017610 0 ustar 00root root 0000000 0000000 // Copyright 2021-present The Atlas Authors. All rights reserved.
// This source code is licensed under the Apache 2.0 license found
// in the LICENSE file in the root directory of this source tree.
package postgres
import (
"testing"
"github.com/DATA-DOG/go-sqlmock"
"ariga.io/atlas/sql/schema"
"github.com/stretchr/testify/require"
)
func TestDiff_TableDiff(t *testing.T) {
type testcase struct {
name string
from, to *schema.Table
wantChanges []schema.Change
wantErr bool
}
tests := []testcase{
{
name: "no changes",
from: &schema.Table{Name: "users", Schema: &schema.Schema{Name: "public"}},
to: &schema.Table{Name: "users"},
},
{
name: "change primary key columns",
from: func() *schema.Table {
t := &schema.Table{Name: "users", Schema: &schema.Schema{Name: "public"}, Columns: []*schema.Column{{Name: "id", Type: &schema.ColumnType{Raw: "int", Type: &schema.IntegerType{T: "int"}}}}}
t.PrimaryKey = &schema.Index{
Parts: []*schema.IndexPart{{C: t.Columns[0]}},
}
return t
}(),
to: &schema.Table{Name: "users"},
wantErr: true,
},
{
name: "change identity attributes",
from: func() *schema.Table {
t := &schema.Table{
Name: "users",
Columns: []*schema.Column{
{Name: "id", Type: &schema.ColumnType{Type: &schema.IntegerType{T: "int"}}},
},
}
t.PrimaryKey = &schema.Index{Parts: []*schema.IndexPart{{C: t.Columns[0]}}}
return t
}(),
to: func() *schema.Table {
t := &schema.Table{
Name: "users",
Columns: []*schema.Column{
{Name: "id", Type: &schema.ColumnType{Type: &schema.IntegerType{T: "int"}}, Attrs: []schema.Attr{&Identity{Sequence: &Sequence{Start: 1024, Increment: 1}}}},
},
}
t.PrimaryKey = &schema.Index{Parts: []*schema.IndexPart{{C: t.Columns[0]}}}
return t
}(),
wantChanges: []schema.Change{
&schema.ModifyColumn{
From: &schema.Column{Name: "id", Type: &schema.ColumnType{Type: &schema.IntegerType{T: "int"}}},
To: &schema.Column{Name: "id", Type: &schema.ColumnType{Type: &schema.IntegerType{T: "int"}}, Attrs: []schema.Attr{&Identity{Sequence: &Sequence{Start: 1024, Increment: 1}}}},
Change: schema.ChangeAttr,
},
},
},
{
name: "drop partition key",
from: schema.NewTable("logs").
AddAttrs(&Partition{
T: PartitionTypeRange,
Parts: []*PartitionPart{{C: schema.NewColumn("c")}},
}),
to: schema.NewTable("logs"),
wantErr: true,
},
{
name: "add partition key",
from: schema.NewTable("logs"),
to: schema.NewTable("logs").
AddAttrs(&Partition{
T: PartitionTypeRange,
Parts: []*PartitionPart{{C: schema.NewColumn("c")}},
}),
wantErr: true,
},
{
name: "change partition key column",
from: schema.NewTable("logs").
AddAttrs(&Partition{
T: PartitionTypeRange,
Parts: []*PartitionPart{{C: schema.NewColumn("c")}},
}),
to: schema.NewTable("logs").
AddAttrs(&Partition{
T: PartitionTypeRange,
Parts: []*PartitionPart{{C: schema.NewColumn("d")}},
}),
wantErr: true,
},
{
name: "change partition key type",
from: schema.NewTable("logs").
AddAttrs(&Partition{
T: PartitionTypeRange,
Parts: []*PartitionPart{{C: schema.NewColumn("c")}},
}),
to: schema.NewTable("logs").
AddAttrs(&Partition{
T: PartitionTypeHash,
Parts: []*PartitionPart{{C: schema.NewColumn("c")}},
}),
wantErr: true,
},
{
name: "add check",
from: &schema.Table{Name: "t1", Schema: &schema.Schema{Name: "public"}},
to: &schema.Table{Name: "t1", Attrs: []schema.Attr{&schema.Check{Name: "t1_c1_check", Expr: "(c1 > 1)"}}},
wantChanges: []schema.Change{
&schema.AddCheck{
C: &schema.Check{Name: "t1_c1_check", Expr: "(c1 > 1)"},
},
},
},
{
name: "drop check",
from: &schema.Table{Name: "t1", Attrs: []schema.Attr{&schema.Check{Name: "t1_c1_check", Expr: "(c1 > 1)"}}},
to: &schema.Table{Name: "t1"},
wantChanges: []schema.Change{
&schema.DropCheck{
C: &schema.Check{Name: "t1_c1_check", Expr: "(c1 > 1)"},
},
},
},
{
name: "add comment",
from: &schema.Table{Name: "t1", Schema: &schema.Schema{Name: "public"}},
to: &schema.Table{Name: "t1", Attrs: []schema.Attr{&schema.Comment{Text: "t1"}}},
wantChanges: []schema.Change{
&schema.AddAttr{
A: &schema.Comment{Text: "t1"},
},
},
},
{
name: "drop comment",
from: &schema.Table{Name: "t1", Schema: &schema.Schema{Name: "public"}, Attrs: []schema.Attr{&schema.Comment{Text: "t1"}}},
to: &schema.Table{Name: "t1"},
wantChanges: []schema.Change{
&schema.ModifyAttr{
From: &schema.Comment{Text: "t1"},
To: &schema.Comment{Text: ""},
},
},
},
{
name: "modify comment",
from: &schema.Table{Name: "t1", Schema: &schema.Schema{Name: "public"}, Attrs: []schema.Attr{&schema.Comment{Text: "t1"}}},
to: &schema.Table{Name: "t1", Attrs: []schema.Attr{&schema.Comment{Text: "t1!"}}},
wantChanges: []schema.Change{
&schema.ModifyAttr{
From: &schema.Comment{Text: "t1"},
To: &schema.Comment{Text: "t1!"},
},
},
},
func() testcase {
var (
s = schema.New("public")
from = schema.NewTable("t1").
SetSchema(s).
AddColumns(
schema.NewIntColumn("c1", "int").
SetGeneratedExpr(&schema.GeneratedExpr{Expr: "1", Type: "STORED"}),
)
to = schema.NewTable("t1").
SetSchema(s).
AddColumns(
schema.NewIntColumn("c1", "int"),
)
)
return testcase{
name: "drop generation expression",
from: from,
to: to,
wantChanges: []schema.Change{
&schema.ModifyColumn{From: from.Columns[0], To: to.Columns[0], Change: schema.ChangeGenerated},
},
}
}(),
{
name: "change generation expression",
from: schema.NewTable("t1").
SetSchema(schema.New("public")).
AddColumns(
schema.NewIntColumn("c1", "int").
SetGeneratedExpr(&schema.GeneratedExpr{Expr: "1", Type: "STORED"}),
),
to: schema.NewTable("t1").
SetSchema(schema.New("public")).
AddColumns(
schema.NewIntColumn("c1", "int").
SetGeneratedExpr(&schema.GeneratedExpr{Expr: "2", Type: "STORED"}),
),
wantErr: true,
},
func() testcase {
var (
from = &schema.Table{
Name: "t1",
Schema: &schema.Schema{
Name: "public",
},
Columns: []*schema.Column{
{Name: "c1", Type: &schema.ColumnType{Raw: "json", Type: &schema.JSONType{T: "json"}}},
{Name: "c2", Type: &schema.ColumnType{Raw: "int8", Type: &schema.IntegerType{T: "int8"}}},
},
}
to = &schema.Table{
Name: "t1",
Columns: []*schema.Column{
{
Name: "c1",
Type: &schema.ColumnType{Raw: "json", Type: &schema.JSONType{T: "json"}, Null: true},
Default: &schema.RawExpr{X: "{}"},
Attrs: []schema.Attr{&schema.Comment{Text: "json comment"}},
},
{Name: "c3", Type: &schema.ColumnType{Raw: "int", Type: &schema.IntegerType{T: "int"}}},
},
}
)
return testcase{
name: "columns",
from: from,
to: to,
wantChanges: []schema.Change{
&schema.ModifyColumn{
From: from.Columns[0],
To: to.Columns[0],
Change: schema.ChangeNull | schema.ChangeComment | schema.ChangeDefault,
},
&schema.DropColumn{C: from.Columns[1]},
&schema.AddColumn{C: to.Columns[1]},
},
}
}(),
// Modify enum type or values.
func() testcase {
var (
from = schema.NewTable("users").
SetSchema(schema.New("public")).
AddColumns(
schema.NewEnumColumn("state", schema.EnumName("state"), schema.EnumValues("on")),
schema.NewEnumColumn("enum1", schema.EnumName("enum1"), schema.EnumValues("a")),
schema.NewEnumColumn("enum3", schema.EnumName("enum3"), schema.EnumValues("a")),
schema.NewEnumColumn("enum4", schema.EnumName("enum4"), schema.EnumValues("a"), schema.EnumSchema(schema.New("public"))),
)
to = schema.NewTable("users").
SetSchema(schema.New("public")).
AddColumns(
// Add value.
schema.NewEnumColumn("state", schema.EnumName("state"), schema.EnumValues("on", "off")),
// Change type.
schema.NewEnumColumn("enum1", schema.EnumName("enum2"), schema.EnumValues("a")),
// No change as schema is optional.
schema.NewEnumColumn("enum3", schema.EnumName("enum3"), schema.EnumValues("a"), schema.EnumSchema(schema.New("public"))),
// Enum type was changed (reside in a different schema).
schema.NewEnumColumn("enum4", schema.EnumName("enum4"), schema.EnumValues("a"), schema.EnumSchema(schema.New("test"))),
)
)
return testcase{
name: "enums",
from: from,
to: to,
wantChanges: []schema.Change{
&schema.ModifyColumn{From: from.Columns[0], To: to.Columns[0], Change: schema.ChangeType},
&schema.ModifyColumn{From: from.Columns[1], To: to.Columns[1], Change: schema.ChangeType},
&schema.ModifyColumn{From: from.Columns[3], To: to.Columns[3], Change: schema.ChangeType},
},
}
}(),
// Modify array of type enum.
func() testcase {
var (
from = schema.NewTable("users").
SetSchema(schema.New("public")).
AddColumns(
schema.NewColumn("a1").SetType(&ArrayType{T: "state[]", Type: &schema.EnumType{T: "state", Values: []string{"on"}}}),
schema.NewColumn("a2").SetType(&ArrayType{T: "state[]", Type: &schema.EnumType{T: "state", Values: []string{"on", "off"}}}),
schema.NewColumn("a3").SetType(&ArrayType{T: "state[]", Type: &schema.EnumType{T: "state", Values: []string{"on", "off"}}}),
)
to = schema.NewTable("users").
SetSchema(schema.New("public")).
AddColumns(
// Add value.
schema.NewColumn("a1").SetType(&ArrayType{T: "state[]", Type: &schema.EnumType{T: "state", Values: []string{"on", "off"}}}),
// Drop value.
schema.NewColumn("a2").SetType(&ArrayType{T: "state[]", Type: &schema.EnumType{T: "state", Values: []string{"on"}}}),
// Same values.
schema.NewColumn("a3").SetType(&ArrayType{T: "state[]", Type: &schema.EnumType{T: "state", Values: []string{"on", "off"}}}),
)
)
return testcase{
name: "enum arrays",
from: from,
to: to,
wantChanges: []schema.Change{
&schema.ModifyColumn{From: from.Columns[0], To: to.Columns[0], Change: schema.ChangeType},
&schema.ModifyColumn{From: from.Columns[1], To: to.Columns[1], Change: schema.ChangeType},
},
}
}(),
func() testcase {
var (
from = &schema.Table{
Name: "t1",
Schema: &schema.Schema{
Name: "public",
},
Columns: []*schema.Column{
{Name: "c1", Type: &schema.ColumnType{Raw: "json", Type: &schema.JSONType{T: "json"}}, Default: &schema.RawExpr{X: "'{}'"}},
{Name: "c2", Type: &schema.ColumnType{Raw: "int8", Type: &schema.IntegerType{T: "int8"}}},
{Name: "c3", Type: &schema.ColumnType{Raw: "int", Type: &schema.IntegerType{T: "int"}}},
},
}
to = &schema.Table{
Name: "t1",
Schema: &schema.Schema{
Name: "public",
},
Columns: []*schema.Column{
{Name: "c1", Type: &schema.ColumnType{Raw: "json", Type: &schema.JSONType{T: "json"}}, Default: &schema.RawExpr{X: "'{}'::json"}},
{Name: "c2", Type: &schema.ColumnType{Raw: "int8", Type: &schema.IntegerType{T: "int8"}}},
{Name: "c3", Type: &schema.ColumnType{Raw: "int", Type: &schema.IntegerType{T: "int"}}},
},
}
)
from.Indexes = []*schema.Index{
{Name: "c1_index", Unique: true, Table: from, Parts: []*schema.IndexPart{{SeqNo: 1, C: from.Columns[0]}}},
{Name: "c2_unique", Unique: true, Table: from, Parts: []*schema.IndexPart{{SeqNo: 1, C: from.Columns[1]}}},
{Name: "c3_predicate", Table: from, Parts: []*schema.IndexPart{{SeqNo: 1, C: from.Columns[1]}}},
{Name: "c4_predicate", Table: from, Parts: []*schema.IndexPart{{SeqNo: 1, C: from.Columns[1]}}, Attrs: []schema.Attr{&IndexPredicate{P: "(c4 <> NULL)"}}},
{Name: "c4_storage_params", Table: from, Parts: []*schema.IndexPart{{SeqNo: 1, C: from.Columns[1]}}, Attrs: []schema.Attr{&IndexStorageParams{PagesPerRange: 4}}},
{Name: "c5_include_no_change", Table: from, Parts: []*schema.IndexPart{{SeqNo: 1, C: from.Columns[1]}}, Attrs: []schema.Attr{&IndexInclude{Columns: from.Columns[:1]}}},
{Name: "c5_include_added", Table: from, Parts: []*schema.IndexPart{{SeqNo: 1, C: from.Columns[1]}}},
{Name: "c5_include_dropped", Table: from, Parts: []*schema.IndexPart{{SeqNo: 1, C: from.Columns[1]}}, Attrs: []schema.Attr{&IndexInclude{Columns: from.Columns[:1]}}},
}
to.Indexes = []*schema.Index{
{Name: "c1_index", Table: from, Parts: []*schema.IndexPart{{SeqNo: 1, C: from.Columns[0]}}},
{Name: "c3_unique", Unique: true, Table: from, Parts: []*schema.IndexPart{{SeqNo: 1, C: to.Columns[1]}}},
{Name: "c3_predicate", Table: from, Parts: []*schema.IndexPart{{SeqNo: 1, C: from.Columns[1]}}, Attrs: []schema.Attr{&IndexPredicate{P: "c3 <> NULL"}}},
{Name: "c4_predicate", Table: from, Parts: []*schema.IndexPart{{SeqNo: 1, C: from.Columns[1]}}, Attrs: []schema.Attr{&IndexPredicate{P: "c4 <> NULL"}}},
{Name: "c4_storage_params", Table: from, Parts: []*schema.IndexPart{{SeqNo: 1, C: from.Columns[1]}}, Attrs: []schema.Attr{&IndexStorageParams{PagesPerRange: 2}}},
{Name: "c5_include_no_change", Table: from, Parts: []*schema.IndexPart{{SeqNo: 1, C: from.Columns[1]}}, Attrs: []schema.Attr{&IndexInclude{Columns: from.Columns[:1]}}},
{Name: "c5_include_added", Table: from, Parts: []*schema.IndexPart{{SeqNo: 1, C: from.Columns[1]}}, Attrs: []schema.Attr{&IndexInclude{Columns: from.Columns[:1]}}},
{Name: "c5_include_dropped", Table: from, Parts: []*schema.IndexPart{{SeqNo: 1, C: from.Columns[1]}}},
}
return testcase{
name: "indexes",
from: from,
to: to,
wantChanges: []schema.Change{
&schema.ModifyIndex{From: from.Indexes[0], To: to.Indexes[0], Change: schema.ChangeUnique},
&schema.DropIndex{I: from.Indexes[1]},
&schema.ModifyIndex{From: from.Indexes[2], To: to.Indexes[2], Change: schema.ChangeAttr},
&schema.ModifyIndex{From: from.Indexes[4], To: to.Indexes[4], Change: schema.ChangeAttr},
&schema.ModifyIndex{From: from.Indexes[6], To: to.Indexes[6], Change: schema.ChangeAttr},
&schema.ModifyIndex{From: from.Indexes[7], To: to.Indexes[7], Change: schema.ChangeAttr},
&schema.AddIndex{I: to.Indexes[1]},
},
}
}(),
func() testcase {
var (
ref = &schema.Table{
Name: "t2",
Schema: &schema.Schema{
Name: "public",
},
Columns: []*schema.Column{
{Name: "id", Type: &schema.ColumnType{Raw: "int", Type: &schema.IntegerType{T: "int"}}},
{Name: "ref_id", Type: &schema.ColumnType{Raw: "int", Type: &schema.IntegerType{T: "int"}}},
},
}
from = &schema.Table{
Name: "t1",
Schema: &schema.Schema{
Name: "public",
},
Columns: []*schema.Column{
{Name: "t2_id", Type: &schema.ColumnType{Raw: "int", Type: &schema.IntegerType{T: "int"}}},
},
}
to = &schema.Table{
Name: "t1",
Schema: &schema.Schema{
Name: "public",
},
Columns: []*schema.Column{
{Name: "t2_id", Type: &schema.ColumnType{Raw: "int", Type: &schema.IntegerType{T: "int"}}},
},
}
)
from.ForeignKeys = []*schema.ForeignKey{
{Table: from, Columns: from.Columns, RefTable: ref, RefColumns: ref.Columns[:1]},
}
to.ForeignKeys = []*schema.ForeignKey{
{Table: to, Columns: to.Columns, RefTable: ref, RefColumns: ref.Columns[1:]},
}
return testcase{
name: "foreign-keys",
from: from,
to: to,
wantChanges: []schema.Change{
&schema.ModifyForeignKey{
From: from.ForeignKeys[0],
To: to.ForeignKeys[0],
Change: schema.ChangeRefColumn,
},
},
}
}(),
}
for _, tt := range tests {
db, m, err := sqlmock.New()
require.NoError(t, err)
mock{m}.version("130000")
drv, err := Open(db)
require.NoError(t, err)
t.Run(tt.name, func(t *testing.T) {
changes, err := drv.TableDiff(tt.from, tt.to)
require.Equalf(t, tt.wantErr, err != nil, "got: %v", err)
require.EqualValues(t, tt.wantChanges, changes)
})
}
}
func TestDiff_SchemaDiff(t *testing.T) {
db, m, err := sqlmock.New()
require.NoError(t, err)
mock{m}.version("130000")
drv, err := Open(db)
require.NoError(t, err)
from := &schema.Schema{
Tables: []*schema.Table{
{Name: "users"},
{Name: "pets"},
},
}
to := &schema.Schema{
Tables: []*schema.Table{
{
Name: "users",
Columns: []*schema.Column{
{Name: "t2_id", Type: &schema.ColumnType{Raw: "int", Type: &schema.IntegerType{T: "int"}}},
},
},
{Name: "groups"},
},
}
from.Tables[0].Schema = from
from.Tables[1].Schema = from
changes, err := drv.SchemaDiff(from, to)
require.NoError(t, err)
require.EqualValues(t, []schema.Change{
&schema.ModifyTable{T: to.Tables[0], Changes: []schema.Change{&schema.AddColumn{C: to.Tables[0].Columns[0]}}},
&schema.DropTable{T: from.Tables[1]},
&schema.AddTable{T: to.Tables[1]},
}, changes)
}
atlas-0.7.2/sql/postgres/driver.go 0000664 0000000 0000000 00000026113 14314555116 0017123 0 ustar 00root root 0000000 0000000 // Copyright 2021-present The Atlas Authors. All rights reserved.
// This source code is licensed under the Apache 2.0 license found
// in the LICENSE file in the root directory of this source tree.
package postgres
import (
"context"
"database/sql"
"errors"
"fmt"
"hash/fnv"
"net/url"
"strconv"
"time"
"ariga.io/atlas/sql/internal/sqlx"
"ariga.io/atlas/sql/migrate"
"ariga.io/atlas/sql/schema"
"ariga.io/atlas/sql/sqlclient"
)
type (
// Driver represents a PostgreSQL driver for introspecting database schemas,
// generating diff between schema elements and apply migrations changes.
Driver struct {
conn
schema.Differ
schema.Inspector
migrate.PlanApplier
schema string // the schema given in the `search_path` parameter (if given)
}
// database connection and its information.
conn struct {
schema.ExecQuerier
// System variables that are set on `Open`.
collate string
ctype string
version int
crdb bool
}
)
// DriverName holds the name used for registration.
const DriverName = "postgres"
func init() {
sqlclient.Register(
DriverName,
sqlclient.OpenerFunc(opener),
sqlclient.RegisterDriverOpener(Open),
sqlclient.RegisterFlavours("postgresql"),
sqlclient.RegisterCodec(MarshalHCL, EvalHCL),
sqlclient.RegisterURLParser(parser{}),
)
}
func opener(_ context.Context, u *url.URL) (*sqlclient.Client, error) {
ur := parser{}.ParseURL(u)
db, err := sql.Open(DriverName, ur.DSN)
if err != nil {
return nil, err
}
drv, err := Open(db)
if err != nil {
if cerr := db.Close(); cerr != nil {
err = fmt.Errorf("%w: %v", err, cerr)
}
return nil, err
}
drv.(*Driver).schema = ur.Schema
return &sqlclient.Client{
Name: DriverName,
DB: db,
URL: ur,
Driver: drv,
}, nil
}
// Open opens a new PostgreSQL driver.
func Open(db schema.ExecQuerier) (migrate.Driver, error) {
c := conn{ExecQuerier: db}
rows, err := db.QueryContext(context.Background(), paramsQuery)
if err != nil {
return nil, fmt.Errorf("postgres: scanning system variables: %w", err)
}
params, err := sqlx.ScanStrings(rows)
if err != nil {
return nil, fmt.Errorf("postgres: failed scanning rows: %w", err)
}
if len(params) != 3 && len(params) != 4 {
return nil, fmt.Errorf("postgres: unexpected number of rows: %d", len(params))
}
c.ctype, c.collate = params[1], params[2]
if c.version, err = strconv.Atoi(params[0]); err != nil {
return nil, fmt.Errorf("postgres: malformed version: %s: %w", params[0], err)
}
if c.version < 10_00_00 {
return nil, fmt.Errorf("postgres: unsupported postgres version: %d", c.version)
}
// Means we are connected to CockroachDB because we have a result for name='crdb_version'. see `paramsQuery`.
if c.crdb = len(params) == 4; c.crdb {
return &Driver{
conn: c,
Differ: &sqlx.Diff{DiffDriver: &crdbDiff{diff{c}}},
Inspector: &crdbInspect{inspect{c}},
PlanApplier: &planApply{c},
}, nil
}
return &Driver{
conn: c,
Differ: &sqlx.Diff{DiffDriver: &diff{c}},
Inspector: &inspect{c},
PlanApplier: &planApply{c},
}, nil
}
func (d *Driver) dev() *sqlx.DevDriver {
return &sqlx.DevDriver{
Driver: d,
MaxNameLen: 63,
PatchColumn: func(s *schema.Schema, c *schema.Column) {
if e, ok := hasEnumType(c); ok {
e.Schema = s
}
},
}
}
// NormalizeRealm returns the normal representation of the given database.
func (d *Driver) NormalizeRealm(ctx context.Context, r *schema.Realm) (*schema.Realm, error) {
return d.dev().NormalizeRealm(ctx, r)
}
// NormalizeSchema returns the normal representation of the given database.
func (d *Driver) NormalizeSchema(ctx context.Context, s *schema.Schema) (*schema.Schema, error) {
return d.dev().NormalizeSchema(ctx, s)
}
// Lock implements the schema.Locker interface.
func (d *Driver) Lock(ctx context.Context, name string, timeout time.Duration) (schema.UnlockFunc, error) {
conn, err := sqlx.SingleConn(ctx, d.ExecQuerier)
if err != nil {
return nil, err
}
h := fnv.New32()
h.Write([]byte(name))
id := h.Sum32()
if err := acquire(ctx, conn, id, timeout); err != nil {
conn.Close()
return nil, err
}
return func() error {
defer conn.Close()
rows, err := conn.QueryContext(ctx, "SELECT pg_advisory_unlock($1)", id)
if err != nil {
return err
}
switch released, err := sqlx.ScanNullBool(rows); {
case err != nil:
return err
case !released.Valid || !released.Bool:
return fmt.Errorf("sql/postgres: failed releasing lock %d", id)
}
return nil
}, nil
}
// Snapshot implements migrate.Snapshoter.
func (d *Driver) Snapshot(ctx context.Context) (migrate.RestoreFunc, error) {
// Postgres will only then be considered bound to a schema if the `search_path` was given.
// In all other cases, the connection is considered bound to the realm.
if d.schema != "" {
s, err := d.InspectSchema(ctx, d.schema, nil)
if err != nil {
return nil, err
}
if len(s.Tables) > 0 {
return nil, migrate.NotCleanError{Reason: fmt.Sprintf("found table %q in connected schema", s.Tables[0].Name)}
}
return func(ctx context.Context) error {
current, err := d.InspectSchema(ctx, s.Name, nil)
if err != nil {
return err
}
changes, err := d.SchemaDiff(current, s)
if err != nil {
return err
}
return d.ApplyChanges(ctx, changes)
}, nil
}
// Not bound to a schema.
realm, err := d.InspectRealm(ctx, nil)
if err != nil {
return nil, err
}
restore := func(ctx context.Context) error {
current, err := d.InspectRealm(ctx, nil)
if err != nil {
return err
}
changes, err := d.RealmDiff(current, realm)
if err != nil {
return err
}
return d.ApplyChanges(ctx, changes)
}
// Postgres is considered clean, if there are no schemas or the public schema has no tables.
if len(realm.Schemas) == 0 {
return restore, nil
}
if s, ok := realm.Schema("public"); len(realm.Schemas) == 1 && ok {
if len(s.Tables) > 0 {
return nil, migrate.NotCleanError{Reason: fmt.Sprintf("found table %q in schema %q", s.Tables[0].Name, s.Name)}
}
return restore, nil
}
return nil, migrate.NotCleanError{Reason: fmt.Sprintf("found schema %q", realm.Schemas[0].Name)}
}
// CheckClean implements migrate.CleanChecker.
func (d *Driver) CheckClean(ctx context.Context, revT *migrate.TableIdent) error {
if d.schema != "" {
switch s, err := d.InspectSchema(ctx, d.schema, nil); {
case err != nil:
return err
case len(s.Tables) == 0, (revT != nil && revT.Schema == "" || s.Name == revT.Schema) && len(s.Tables) == 1 && s.Tables[0].Name == revT.Name:
return nil
default:
return &migrate.NotCleanError{Reason: fmt.Sprintf("found table %q in schema %q", s.Tables[0].Name, s.Name)}
}
}
r, err := d.InspectRealm(ctx, nil)
if err != nil {
return err
}
for _, s := range r.Schemas {
switch {
case len(s.Tables) == 0 && s.Name == "public":
case len(s.Tables) == 0 || s.Name != revT.Schema:
return &migrate.NotCleanError{Reason: fmt.Sprintf("found schema %q", s.Name)}
case len(s.Tables) > 1:
return &migrate.NotCleanError{Reason: fmt.Sprintf("found %d tables in schema %q", len(s.Tables), s.Name)}
case len(s.Tables) == 1 && s.Tables[0].Name != revT.Name:
return &migrate.NotCleanError{Reason: fmt.Sprintf("found table %q in schema %q", s.Tables[0].Name, s.Name)}
}
}
return nil
}
func acquire(ctx context.Context, conn schema.ExecQuerier, id uint32, timeout time.Duration) error {
switch {
// With timeout (context-based).
case timeout > 0:
var cancel context.CancelFunc
ctx, cancel = context.WithTimeout(ctx, timeout)
defer cancel()
fallthrough
// Infinite timeout.
case timeout < 0:
rows, err := conn.QueryContext(ctx, "SELECT pg_advisory_lock($1)", id)
if errors.Is(err, context.DeadlineExceeded) || errors.Is(err, context.Canceled) {
err = schema.ErrLocked
}
if err != nil {
return err
}
return rows.Close()
// No timeout.
default:
rows, err := conn.QueryContext(ctx, "SELECT pg_try_advisory_lock($1)", id)
if err != nil {
return err
}
acquired, err := sqlx.ScanNullBool(rows)
if err != nil {
return err
}
if !acquired.Bool {
return schema.ErrLocked
}
return nil
}
}
// supportsIndexInclude reports if the server supports the INCLUDE clause.
func (c *conn) supportsIndexInclude() bool {
return c.version >= 11_00_00
}
type parser struct{}
// ParseURL implements the sqlclient.URLParser interface.
func (parser) ParseURL(u *url.URL) *sqlclient.URL {
return &sqlclient.URL{URL: u, DSN: u.String(), Schema: u.Query().Get("search_path")}
}
// ChangeSchema implements the sqlclient.SchemaChanger interface.
func (parser) ChangeSchema(u *url.URL, s string) *url.URL {
nu := *u
q := nu.Query()
q.Set("search_path", s)
nu.RawQuery = q.Encode()
return &nu
}
// Standard column types (and their aliases) as defined in
// PostgreSQL codebase/website.
const (
TypeBit = "bit"
TypeBitVar = "bit varying"
TypeBoolean = "boolean"
TypeBool = "bool" // boolean.
TypeBytea = "bytea"
TypeCharacter = "character"
TypeChar = "char" // character
TypeCharVar = "character varying"
TypeVarChar = "varchar" // character varying
TypeText = "text"
TypeSmallInt = "smallint"
TypeInteger = "integer"
TypeBigInt = "bigint"
TypeInt = "int" // integer.
TypeInt2 = "int2" // smallint.
TypeInt4 = "int4" // integer.
TypeInt8 = "int8" // bigint.
TypeCIDR = "cidr"
TypeInet = "inet"
TypeMACAddr = "macaddr"
TypeMACAddr8 = "macaddr8"
TypeCircle = "circle"
TypeLine = "line"
TypeLseg = "lseg"
TypeBox = "box"
TypePath = "path"
TypePolygon = "polygon"
TypePoint = "point"
TypeDate = "date"
TypeTime = "time" // time without time zone
TypeTimeTZ = "timetz" // time with time zone
TypeTimeWTZ = "time with time zone"
TypeTimeWOTZ = "time without time zone"
TypeTimestamp = "timestamp" // timestamp without time zone
TypeTimestampTZ = "timestamptz"
TypeTimestampWTZ = "timestamp with time zone"
TypeTimestampWOTZ = "timestamp without time zone"
TypeDouble = "double precision"
TypeReal = "real"
TypeFloat8 = "float8" // double precision
TypeFloat4 = "float4" // real
TypeFloat = "float" // float(p).
TypeNumeric = "numeric"
TypeDecimal = "decimal" // numeric
TypeSmallSerial = "smallserial" // smallint with auto_increment.
TypeSerial = "serial" // integer with auto_increment.
TypeBigSerial = "bigserial" // bigint with auto_increment.
TypeSerial2 = "serial2" // smallserial
TypeSerial4 = "serial4" // serial
TypeSerial8 = "serial8" // bigserial
TypeArray = "array"
TypeXML = "xml"
TypeJSON = "json"
TypeJSONB = "jsonb"
TypeUUID = "uuid"
TypeMoney = "money"
TypeInterval = "interval"
TypeUserDefined = "user-defined"
)
// List of supported index types.
const (
IndexTypeBTree = "BTREE"
IndexTypeHash = "HASH"
IndexTypeGIN = "GIN"
IndexTypeGiST = "GIST"
IndexTypeBRIN = "BRIN"
defaultPagePerRange = 128
)
// List of "GENERATED" types.
const (
GeneratedTypeAlways = "ALWAYS"
GeneratedTypeByDefault = "BY_DEFAULT" // BY DEFAULT.
)
// List of PARTITION KEY types.
const (
PartitionTypeRange = "RANGE"
PartitionTypeList = "LIST"
PartitionTypeHash = "HASH"
)
atlas-0.7.2/sql/postgres/driver_test.go 0000664 0000000 0000000 00000012462 14314555116 0020164 0 ustar 00root root 0000000 0000000 // Copyright 2021-present The Atlas Authors. All rights reserved.
// This source code is licensed under the Apache 2.0 license found
// in the LICENSE file in the root directory of this source tree.
package postgres
import (
"context"
"io"
"testing"
"time"
"ariga.io/atlas/sql/internal/sqltest"
"ariga.io/atlas/sql/migrate"
"ariga.io/atlas/sql/schema"
"github.com/DATA-DOG/go-sqlmock"
"github.com/stretchr/testify/require"
)
func TestDriver_LockAcquired(t *testing.T) {
db, m, err := sqlmock.New()
require.NoError(t, err)
name, hash := "name", 797654004
m.ExpectQuery(sqltest.Escape("SELECT pg_try_advisory_lock($1)")).
WithArgs(hash).
WillReturnRows(sqlmock.NewRows([]string{"pg_advisory_lock"}).AddRow(1)).
RowsWillBeClosed()
m.ExpectQuery(sqltest.Escape("SELECT pg_advisory_unlock($1)")).
WithArgs(hash).
WillReturnRows(sqlmock.NewRows([]string{"pg_advisory_unlock"}).AddRow(1)).
RowsWillBeClosed()
d := &Driver{}
d.ExecQuerier = db
unlock, err := d.Lock(context.Background(), name, 0)
require.NoError(t, err)
require.NoError(t, unlock())
require.NoError(t, m.ExpectationsWereMet())
}
func TestDriver_LockError(t *testing.T) {
db, m, err := sqlmock.New()
require.NoError(t, err)
d := &Driver{}
d.ExecQuerier = db
name, hash := "migrate", 979249972
t.Run("Timeout", func(t *testing.T) {
m.ExpectQuery(sqltest.Escape("SELECT pg_advisory_lock($1)")).
WithArgs(hash).
WillReturnError(context.DeadlineExceeded).
RowsWillBeClosed()
unlock, err := d.Lock(context.Background(), name, time.Minute)
require.Equal(t, schema.ErrLocked, err)
require.Nil(t, unlock)
})
t.Run("Internal", func(t *testing.T) {
m.ExpectQuery(sqltest.Escape("SELECT pg_advisory_lock($1)")).
WithArgs(hash).
WillReturnError(io.EOF).
RowsWillBeClosed()
unlock, err := d.Lock(context.Background(), name, time.Minute)
require.Equal(t, io.EOF, err)
require.Nil(t, unlock)
})
}
func TestDriver_UnlockError(t *testing.T) {
db, m, err := sqlmock.New()
require.NoError(t, err)
d := &Driver{}
d.ExecQuerier = db
name, hash := "up", 1551306158
acquired := func() {
m.ExpectQuery(sqltest.Escape("SELECT pg_try_advisory_lock($1)")).
WithArgs(hash).
WillReturnRows(sqlmock.NewRows([]string{"pg_try_advisory_lock"}).AddRow(1)).
RowsWillBeClosed()
}
t.Run("NotHeld", func(t *testing.T) {
acquired()
unlock, err := d.Lock(context.Background(), name, 0)
require.NoError(t, err)
m.ExpectQuery(sqltest.Escape("SELECT pg_advisory_unlock($1)")).
WithArgs(hash).
WillReturnRows(sqlmock.NewRows([]string{"pg_advisory_unlock"}).AddRow(0)).
RowsWillBeClosed()
require.Error(t, unlock())
})
t.Run("Internal", func(t *testing.T) {
acquired()
unlock, err := d.Lock(context.Background(), name, 0)
require.NoError(t, err)
m.ExpectQuery(sqltest.Escape("SELECT pg_advisory_unlock($1)")).
WithArgs(hash).
WillReturnRows(sqlmock.NewRows([]string{"pg_advisory_unlock"}).AddRow(nil)).
RowsWillBeClosed()
require.Error(t, unlock())
})
}
func TestDriver_CheckClean(t *testing.T) {
s := schema.New("test")
drv := &Driver{Inspector: &mockInspector{schema: s}, schema: "test"}
// Empty schema.
err := drv.CheckClean(context.Background(), nil)
require.NoError(t, err)
// Revisions table found.
s.AddTables(schema.NewTable("revisions"))
err = drv.CheckClean(context.Background(), &migrate.TableIdent{Name: "revisions", Schema: "test"})
require.NoError(t, err)
// Multiple tables.
s.Tables = []*schema.Table{schema.NewTable("a"), schema.NewTable("revisions")}
err = drv.CheckClean(context.Background(), &migrate.TableIdent{Name: "revisions", Schema: "test"})
require.EqualError(t, err, `sql/migrate: connected database is not clean: found table "a" in schema "test"`)
r := schema.NewRealm()
drv.schema = ""
drv.Inspector = &mockInspector{realm: r}
// Empty realm.
err = drv.CheckClean(context.Background(), nil)
require.NoError(t, err)
// Revisions table found.
s.Tables = []*schema.Table{schema.NewTable("revisions").SetSchema(s)}
r.AddSchemas(s)
err = drv.CheckClean(context.Background(), &migrate.TableIdent{Name: "revisions", Schema: "test"})
require.NoError(t, err)
// Unknown table.
s.Tables[0].Name = "unknown"
err = drv.CheckClean(context.Background(), &migrate.TableIdent{Schema: "test", Name: "revisions"})
require.EqualError(t, err, `sql/migrate: connected database is not clean: found table "unknown" in schema "test"`)
// Multiple tables.
s.Tables = []*schema.Table{schema.NewTable("a"), schema.NewTable("revisions")}
err = drv.CheckClean(context.Background(), &migrate.TableIdent{Schema: "test", Name: "revisions"})
require.EqualError(t, err, `sql/migrate: connected database is not clean: found 2 tables in schema "test"`)
// With auto created public schema.
s.Tables = []*schema.Table{schema.NewTable("revisions")}
r.AddSchemas(schema.New("public"))
err = drv.CheckClean(context.Background(), &migrate.TableIdent{Schema: "test", Name: "revisions"})
require.NoError(t, err)
}
type mockInspector struct {
schema.Inspector
realm *schema.Realm
schema *schema.Schema
}
func (m *mockInspector) InspectSchema(context.Context, string, *schema.InspectOptions) (*schema.Schema, error) {
if m.schema == nil {
return nil, &schema.NotExistError{}
}
return m.schema, nil
}
func (m *mockInspector) InspectRealm(context.Context, *schema.InspectRealmOption) (*schema.Realm, error) {
return m.realm, nil
}
atlas-0.7.2/sql/postgres/inspect.go 0000664 0000000 0000000 00000077402 14314555116 0017304 0 ustar 00root root 0000000 0000000 // Copyright 2021-present The Atlas Authors. All rights reserved.
// This source code is licensed under the Apache 2.0 license found
// in the LICENSE file in the root directory of this source tree.
package postgres
import (
"context"
"database/sql"
"fmt"
"regexp"
"strconv"
"strings"
"ariga.io/atlas/sql/internal/sqlx"
"ariga.io/atlas/sql/schema"
)
// A diff provides a PostgreSQL implementation for schema.Inspector.
type inspect struct{ conn }
var _ schema.Inspector = (*inspect)(nil)
// InspectRealm returns schema descriptions of all resources in the given realm.
func (i *inspect) InspectRealm(ctx context.Context, opts *schema.InspectRealmOption) (*schema.Realm, error) {
schemas, err := i.schemas(ctx, opts)
if err != nil {
return nil, err
}
if opts == nil {
opts = &schema.InspectRealmOption{}
}
r := schema.NewRealm(schemas...).SetCollation(i.collate)
r.Attrs = append(r.Attrs, &CType{V: i.ctype})
if len(schemas) == 0 || !sqlx.ModeInspectRealm(opts).Is(schema.InspectTables) {
return sqlx.ExcludeRealm(r, opts.Exclude)
}
if err := i.inspectTables(ctx, r, nil); err != nil {
return nil, err
}
sqlx.LinkSchemaTables(schemas)
return sqlx.ExcludeRealm(r, opts.Exclude)
}
// InspectSchema returns schema descriptions of the tables in the given schema.
// If the schema name is empty, the result will be the attached schema.
func (i *inspect) InspectSchema(ctx context.Context, name string, opts *schema.InspectOptions) (s *schema.Schema, err error) {
schemas, err := i.schemas(ctx, &schema.InspectRealmOption{Schemas: []string{name}})
if err != nil {
return nil, err
}
switch n := len(schemas); {
case n == 0:
return nil, &schema.NotExistError{Err: fmt.Errorf("postgres: schema %q was not found", name)}
case n > 1:
return nil, fmt.Errorf("postgres: %d schemas were found for %q", n, name)
}
if opts == nil {
opts = &schema.InspectOptions{}
}
r := schema.NewRealm(schemas...).SetCollation(i.collate)
r.Attrs = append(r.Attrs, &CType{V: i.ctype})
if sqlx.ModeInspectSchema(opts).Is(schema.InspectTables) {
if err := i.inspectTables(ctx, r, opts); err != nil {
return nil, err
}
sqlx.LinkSchemaTables(schemas)
}
return sqlx.ExcludeSchema(r.Schemas[0], opts.Exclude)
}
func (i *inspect) inspectTables(ctx context.Context, r *schema.Realm, opts *schema.InspectOptions) error {
if err := i.tables(ctx, r, opts); err != nil {
return err
}
for _, s := range r.Schemas {
if len(s.Tables) == 0 {
continue
}
if err := i.columns(ctx, s); err != nil {
return err
}
if err := i.indexes(ctx, s); err != nil {
return err
}
if err := i.partitions(s); err != nil {
return err
}
if err := i.fks(ctx, s); err != nil {
return err
}
if err := i.checks(ctx, s); err != nil {
return err
}
}
return nil
}
// table returns the table from the database, or a NotExistError if the table was not found.
func (i *inspect) tables(ctx context.Context, realm *schema.Realm, opts *schema.InspectOptions) error {
var (
args []any
query = fmt.Sprintf(tablesQuery, nArgs(0, len(realm.Schemas)))
)
for _, s := range realm.Schemas {
args = append(args, s.Name)
}
if opts != nil && len(opts.Tables) > 0 {
for _, t := range opts.Tables {
args = append(args, t)
}
query = fmt.Sprintf(tablesQueryArgs, nArgs(0, len(realm.Schemas)), nArgs(len(realm.Schemas), len(opts.Tables)))
}
rows, err := i.QueryContext(ctx, query, args...)
if err != nil {
return err
}
defer rows.Close()
for rows.Next() {
var tSchema, name, comment, partattrs, partstart, partexprs sql.NullString
if err := rows.Scan(&tSchema, &name, &comment, &partattrs, &partstart, &partexprs); err != nil {
return fmt.Errorf("scan table information: %w", err)
}
if !sqlx.ValidString(tSchema) || !sqlx.ValidString(name) {
return fmt.Errorf("invalid schema or table name: %q.%q", tSchema.String, name.String)
}
s, ok := realm.Schema(tSchema.String)
if !ok {
return fmt.Errorf("schema %q was not found in realm", tSchema.String)
}
t := &schema.Table{Name: name.String}
s.AddTables(t)
if sqlx.ValidString(comment) {
t.SetComment(comment.String)
}
if sqlx.ValidString(partattrs) {
t.AddAttrs(&Partition{
start: partstart.String,
attrs: partattrs.String,
exprs: partexprs.String,
})
}
}
return rows.Close()
}
// columns queries and appends the columns of the given table.
func (i *inspect) columns(ctx context.Context, s *schema.Schema) error {
query := columnsQuery
if i.crdb {
query = crdbColumnsQuery
}
rows, err := i.querySchema(ctx, query, s)
if err != nil {
return fmt.Errorf("postgres: querying schema %q columns: %w", s.Name, err)
}
defer rows.Close()
for rows.Next() {
if err := i.addColumn(s, rows); err != nil {
return fmt.Errorf("postgres: %w", err)
}
}
if err := rows.Close(); err != nil {
return err
}
if err := i.enumValues(ctx, s); err != nil {
return err
}
return nil
}
// addColumn scans the current row and adds a new column from it to the table.
func (i *inspect) addColumn(s *schema.Schema, rows *sql.Rows) (err error) {
var (
typid, typelem, maxlen, precision, timeprecision, scale, seqstart, seqinc, seqlast sql.NullInt64
table, name, typ, fmtype, nullable, defaults, identity, genidentity, genexpr, charset, collate, comment, typtype, elemtyp, interval sql.NullString
)
if err = rows.Scan(
&table, &name, &typ, &fmtype, &nullable, &defaults, &maxlen, &precision, &timeprecision, &scale, &interval, &charset,
&collate, &identity, &seqstart, &seqinc, &seqlast, &genidentity, &genexpr, &comment, &typtype, &typelem, &elemtyp, &typid,
); err != nil {
return err
}
t, ok := s.Table(table.String)
if !ok {
return fmt.Errorf("table %q was not found in schema", table.String)
}
c := &schema.Column{
Name: name.String,
Type: &schema.ColumnType{
Raw: typ.String,
Null: nullable.String == "YES",
},
}
c.Type.Type, err = columnType(&columnDesc{
typ: typ.String,
fmtype: fmtype.String,
size: maxlen.Int64,
scale: scale.Int64,
typtype: typtype.String,
typelem: typelem.Int64,
elemtyp: elemtyp.String,
typid: typid.Int64,
interval: interval.String,
precision: precision.Int64,
timePrecision: &timeprecision.Int64,
})
if defaults.Valid {
defaultExpr(c, defaults.String)
}
if identity.String == "YES" {
c.Attrs = append(c.Attrs, &Identity{
Generation: genidentity.String,
Sequence: &Sequence{
Last: seqlast.Int64,
Start: seqstart.Int64,
Increment: seqinc.Int64,
},
})
}
if sqlx.ValidString(genexpr) {
c.Attrs = append(c.Attrs, &schema.GeneratedExpr{
Expr: genexpr.String,
})
}
if sqlx.ValidString(comment) {
c.SetComment(comment.String)
}
if sqlx.ValidString(charset) {
c.SetCharset(charset.String)
}
if sqlx.ValidString(collate) {
c.SetCollation(collate.String)
}
t.Columns = append(t.Columns, c)
return nil
}
// enumValues fills enum columns with their values from the database.
func (i *inspect) enumValues(ctx context.Context, s *schema.Schema) error {
var (
args []any
ids = make(map[int64][]*schema.EnumType)
query = "SELECT enumtypid, enumlabel FROM pg_enum WHERE enumtypid IN (%s)"
newE = func(e1 *enumType) *schema.EnumType {
if _, ok := ids[e1.ID]; !ok {
args = append(args, e1.ID)
}
// Convert the intermediate type to
// the standard schema.EnumType.
e2 := &schema.EnumType{T: e1.T, Schema: s}
if e1.Schema != "" && e1.Schema != s.Name {
e2.Schema = schema.New(e1.Schema)
}
ids[e1.ID] = append(ids[e1.ID], e2)
return e2
}
)
for _, t := range s.Tables {
for _, c := range t.Columns {
switch t := c.Type.Type.(type) {
case *enumType:
e := newE(t)
c.Type.Type = e
c.Type.Raw = e.T
case *ArrayType:
if e, ok := t.Type.(*enumType); ok {
t.Type = newE(e)
}
}
}
}
if len(ids) == 0 {
return nil
}
rows, err := i.QueryContext(ctx, fmt.Sprintf(query, nArgs(0, len(args))), args...)
if err != nil {
return fmt.Errorf("postgres: querying enum values: %w", err)
}
defer rows.Close()
for rows.Next() {
var (
id int64
v string
)
if err := rows.Scan(&id, &v); err != nil {
return fmt.Errorf("postgres: scanning enum label: %w", err)
}
for _, enum := range ids[id] {
enum.Values = append(enum.Values, v)
}
}
return nil
}
// indexes queries and appends the indexes of the given table.
func (i *inspect) indexes(ctx context.Context, s *schema.Schema) error {
query := indexesQuery
switch {
case i.conn.crdb:
return i.crdbIndexes(ctx, s)
case !i.conn.supportsIndexInclude():
query = indexesQueryNoInclude
}
rows, err := i.querySchema(ctx, query, s)
if err != nil {
return fmt.Errorf("postgres: querying schema %q indexes: %w", s.Name, err)
}
defer rows.Close()
if err := i.addIndexes(s, rows); err != nil {
return err
}
return rows.Err()
}
// addIndexes scans the rows and adds the indexes to the table.
func (i *inspect) addIndexes(s *schema.Schema, rows *sql.Rows) error {
names := make(map[string]*schema.Index)
for rows.Next() {
var (
uniq, primary, included bool
table, name, typ string
desc, nullsfirst, nullslast sql.NullBool
column, contype, pred, expr, comment, options sql.NullString
)
if err := rows.Scan(&table, &name, &typ, &column, &included, &primary, &uniq, &contype, &pred, &expr, &desc, &nullsfirst, &nullslast, &comment, &options); err != nil {
return fmt.Errorf("postgres: scanning indexes for schema %q: %w", s.Name, err)
}
t, ok := s.Table(table)
if !ok {
return fmt.Errorf("table %q was not found in schema", table)
}
idx, ok := names[name]
if !ok {
idx = &schema.Index{
Name: name,
Unique: uniq,
Table: t,
Attrs: []schema.Attr{
&IndexType{T: typ},
},
}
if sqlx.ValidString(comment) {
idx.Attrs = append(idx.Attrs, &schema.Comment{Text: comment.String})
}
if sqlx.ValidString(contype) {
idx.Attrs = append(idx.Attrs, &ConType{T: contype.String})
}
if sqlx.ValidString(pred) {
idx.Attrs = append(idx.Attrs, &IndexPredicate{P: pred.String})
}
if sqlx.ValidString(options) {
p, err := newIndexStorage(options.String)
if err != nil {
return err
}
idx.Attrs = append(idx.Attrs, p)
}
names[name] = idx
if primary {
t.PrimaryKey = idx
} else {
t.Indexes = append(t.Indexes, idx)
}
}
part := &schema.IndexPart{SeqNo: len(idx.Parts) + 1, Desc: desc.Bool}
if nullsfirst.Bool || nullslast.Bool {
part.Attrs = append(part.Attrs, &IndexColumnProperty{
NullsFirst: nullsfirst.Bool,
NullsLast: nullslast.Bool,
})
}
switch {
case included:
c, ok := t.Column(column.String)
if !ok {
return fmt.Errorf("postgres: INCLUDE column %q was not found for index %q", column.String, idx.Name)
}
var include IndexInclude
sqlx.Has(idx.Attrs, &include)
include.Columns = append(include.Columns, c)
schema.ReplaceOrAppend(&idx.Attrs, &include)
case sqlx.ValidString(column):
part.C, ok = t.Column(column.String)
if !ok {
return fmt.Errorf("postgres: column %q was not found for index %q", column.String, idx.Name)
}
part.C.Indexes = append(part.C.Indexes, idx)
idx.Parts = append(idx.Parts, part)
case sqlx.ValidString(expr):
part.X = &schema.RawExpr{
X: expr.String,
}
idx.Parts = append(idx.Parts, part)
default:
return fmt.Errorf("postgres: invalid part for index %q", idx.Name)
}
}
return nil
}
// partitions builds the partition each table in the schema.
func (i *inspect) partitions(s *schema.Schema) error {
for _, t := range s.Tables {
var d Partition
if !sqlx.Has(t.Attrs, &d) {
continue
}
switch s := strings.ToLower(d.start); s {
case "r":
d.T = PartitionTypeRange
case "l":
d.T = PartitionTypeList
case "h":
d.T = PartitionTypeHash
default:
return fmt.Errorf("postgres: unexpected partition strategy %q", s)
}
idxs := strings.Split(strings.TrimSpace(d.attrs), " ")
if len(idxs) == 0 {
return fmt.Errorf("postgres: no columns/expressions were found in partition key for column %q", t.Name)
}
for i := range idxs {
switch idx, err := strconv.Atoi(idxs[i]); {
case err != nil:
return fmt.Errorf("postgres: faild parsing partition key index %q", idxs[i])
// An expression.
case idx == 0:
j := sqlx.ExprLastIndex(d.exprs)
if j == -1 {
return fmt.Errorf("postgres: no expression found in partition key: %q", d.exprs)
}
d.Parts = append(d.Parts, &PartitionPart{
X: &schema.RawExpr{X: d.exprs[:j+1]},
})
d.exprs = strings.TrimPrefix(d.exprs[j+1:], ", ")
// A column at index idx-1.
default:
if idx > len(t.Columns) {
return fmt.Errorf("postgres: unexpected column index %d", idx)
}
d.Parts = append(d.Parts, &PartitionPart{
C: t.Columns[idx-1],
})
}
}
schema.ReplaceOrAppend(&t.Attrs, &d)
}
return nil
}
// fks queries and appends the foreign keys of the given table.
func (i *inspect) fks(ctx context.Context, s *schema.Schema) error {
rows, err := i.querySchema(ctx, fksQuery, s)
if err != nil {
return fmt.Errorf("postgres: querying schema %q foreign keys: %w", s.Name, err)
}
defer rows.Close()
if err := sqlx.SchemaFKs(s, rows); err != nil {
return fmt.Errorf("postgres: %w", err)
}
return rows.Err()
}
// checks queries and appends the check constraints of the given table.
func (i *inspect) checks(ctx context.Context, s *schema.Schema) error {
rows, err := i.querySchema(ctx, checksQuery, s)
if err != nil {
return fmt.Errorf("postgres: querying schema %q check constraints: %w", s.Name, err)
}
defer rows.Close()
if err := i.addChecks(s, rows); err != nil {
return err
}
return rows.Err()
}
// addChecks scans the rows and adds the checks to the table.
func (i *inspect) addChecks(s *schema.Schema, rows *sql.Rows) error {
names := make(map[string]*schema.Check)
for rows.Next() {
var (
noInherit bool
table, name, column, clause, indexes string
)
if err := rows.Scan(&table, &name, &clause, &column, &indexes, &noInherit); err != nil {
return fmt.Errorf("postgres: scanning check: %w", err)
}
t, ok := s.Table(table)
if !ok {
return fmt.Errorf("table %q was not found in schema", table)
}
if _, ok := t.Column(column); !ok {
return fmt.Errorf("postgres: column %q was not found for check %q", column, name)
}
check, ok := names[name]
if !ok {
check = &schema.Check{Name: name, Expr: clause, Attrs: []schema.Attr{&CheckColumns{}}}
if noInherit {
check.Attrs = append(check.Attrs, &NoInherit{})
}
names[name] = check
t.Attrs = append(t.Attrs, check)
}
c := check.Attrs[0].(*CheckColumns)
c.Columns = append(c.Columns, column)
}
return nil
}
// schemas returns the list of the schemas in the database.
func (i *inspect) schemas(ctx context.Context, opts *schema.InspectRealmOption) ([]*schema.Schema, error) {
var (
args []any
query = schemasQuery
)
if opts != nil {
switch n := len(opts.Schemas); {
case n == 1 && opts.Schemas[0] == "":
query = fmt.Sprintf(schemasQueryArgs, "= CURRENT_SCHEMA()")
case n == 1 && opts.Schemas[0] != "":
query = fmt.Sprintf(schemasQueryArgs, "= $1")
args = append(args, opts.Schemas[0])
case n > 0:
query = fmt.Sprintf(schemasQueryArgs, "IN ("+nArgs(0, len(opts.Schemas))+")")
for _, s := range opts.Schemas {
args = append(args, s)
}
}
}
rows, err := i.QueryContext(ctx, query, args...)
if err != nil {
return nil, fmt.Errorf("postgres: querying schemas: %w", err)
}
defer rows.Close()
var schemas []*schema.Schema
for rows.Next() {
var name string
if err := rows.Scan(&name); err != nil {
return nil, err
}
schemas = append(schemas, &schema.Schema{
Name: name,
})
}
if err := rows.Close(); err != nil {
return nil, err
}
return schemas, nil
}
func (i *inspect) querySchema(ctx context.Context, query string, s *schema.Schema) (*sql.Rows, error) {
args := []any{s.Name}
for _, t := range s.Tables {
args = append(args, t.Name)
}
return i.QueryContext(ctx, fmt.Sprintf(query, nArgs(1, len(s.Tables))), args...)
}
func nArgs(start, n int) string {
var b strings.Builder
for i := 1; i <= n; i++ {
if i > 1 {
b.WriteString(", ")
}
b.WriteByte('$')
b.WriteString(strconv.Itoa(start + i))
}
return b.String()
}
var reNextval = regexp.MustCompile(`(?i) *nextval\('(?:[\w$]+\.)*([\w$]+_[\w$]+_seq)'(?:::regclass)*\) *$`)
func defaultExpr(c *schema.Column, s string) {
switch m := reNextval.FindStringSubmatch(s); {
// The definition of "" is equivalent to specifying:
// " NOT NULL DEFAULT nextval('
__seq')".
// https://postgresql.org/docs/current/datatype-numeric.html#DATATYPE-SERIAL.
case len(m) == 2:
tt, ok := c.Type.Type.(*schema.IntegerType)
if !ok {
return
}
st := &SerialType{SequenceName: m[1]}
st.SetType(tt)
c.Type.Raw = st.T
c.Type.Type = st
case sqlx.IsLiteralBool(s), sqlx.IsLiteralNumber(s), sqlx.IsQuoted(s, '\''):
c.Default = &schema.Literal{V: s}
default:
var x schema.Expr = &schema.RawExpr{X: s}
// Try casting or fallback to raw expressions (e.g. column text[] has the default of '{}':text[]).
if v, ok := canConvert(c.Type, s); ok {
x = &schema.Literal{V: v}
}
c.Default = x
}
}
func canConvert(t *schema.ColumnType, x string) (string, bool) {
i := strings.LastIndex(x, "::")
if i == -1 || !sqlx.IsQuoted(x[:i], '\'') {
return "", false
}
q := x[0:i]
x = x[1 : i-1]
switch t.Type.(type) {
case *enumType:
return q, true
case *schema.BoolType:
if sqlx.IsLiteralBool(x) {
return x, true
}
case *schema.DecimalType, *schema.IntegerType, *schema.FloatType:
if sqlx.IsLiteralNumber(x) {
return x, true
}
case *ArrayType, *schema.BinaryType, *schema.JSONType, *NetworkType, *schema.SpatialType, *schema.StringType, *schema.TimeType, *UUIDType, *XMLType:
return q, true
}
return "", false
}
type (
// CType describes the character classification setting (LC_CTYPE).
CType struct {
schema.Attr
V string
}
// UserDefinedType defines a user-defined type attribute.
UserDefinedType struct {
schema.Type
T string
}
// enumType represents an enum type. It serves aa intermediate representation of a Postgres enum type,
// to temporary save TypeID and TypeName of an enum column until the enum values can be extracted.
enumType struct {
schema.Type
T string // Type name.
Schema string // Optional schema name.
ID int64 // Type id.
Values []string
}
// ArrayType defines an array type.
// https://postgresql.org/docs/current/arrays.html
ArrayType struct {
schema.Type // Underlying items type (e.g. varchar(255)).
T string // Formatted type (e.g. int[]).
}
// BitType defines a bit type.
// https://postgresql.org/docs/current/datatype-bit.html
BitType struct {
schema.Type
T string
Len int64
}
// IntervalType defines an interval type.
// https://postgresql.org/docs/current/datatype-datetime.html
IntervalType struct {
schema.Type
T string // Type name.
F string // Optional field. YEAR, MONTH, ..., MINUTE TO SECOND.
Precision *int // Optional precision.
}
// A NetworkType defines a network type.
// https://postgresql.org/docs/current/datatype-net-types.html
NetworkType struct {
schema.Type
T string
Len int64
}
// A CurrencyType defines a currency type.
CurrencyType struct {
schema.Type
T string
}
// A SerialType defines a serial type.
// https://postgresql.org/docs/current/datatype-numeric.html#DATATYPE-SERIAL
SerialType struct {
schema.Type
T string
Precision int
// SequenceName holds the inspected sequence name attached to the column.
// It defaults to
__seq when the column is created, but may
// be different in case the table or the column was renamed.
SequenceName string
}
// A UUIDType defines a UUID type.
UUIDType struct {
schema.Type
T string
}
// A XMLType defines an XML type.
XMLType struct {
schema.Type
T string
}
// ConType describes constraint type.
// https://postgresql.org/docs/current/catalog-pg-constraint.html
ConType struct {
schema.Attr
T string // c, f, p, u, t, x.
}
// Sequence defines (the supported) sequence options.
// https://postgresql.org/docs/current/sql-createsequence.html
Sequence struct {
Start, Increment int64
// Last sequence value written to disk.
// https://postgresql.org/docs/current/view-pg-sequences.html.
Last int64
}
// Identity defines an identity column.
Identity struct {
schema.Attr
Generation string // ALWAYS, BY DEFAULT.
Sequence *Sequence
}
// IndexType represents an index type.
// https://postgresql.org/docs/current/indexes-types.html
IndexType struct {
schema.Attr
T string // BTREE, BRIN, HASH, GiST, SP-GiST, GIN.
}
// IndexPredicate describes a partial index predicate.
// https://postgresql.org/docs/current/catalog-pg-index.html
IndexPredicate struct {
schema.Attr
P string
}
// IndexColumnProperty describes an index column property.
// https://postgresql.org/docs/current/functions-info.html#FUNCTIONS-INFO-INDEX-COLUMN-PROPS
IndexColumnProperty struct {
schema.Attr
// NullsFirst defaults to true for DESC indexes.
NullsFirst bool
// NullsLast defaults to true for ASC indexes.
NullsLast bool
}
// IndexStorageParams describes index storage parameters add with the WITH clause.
// https://postgresql.org/docs/current/sql-createindex.html#SQL-CREATEINDEX-STORAGE-PARAMETERS
IndexStorageParams struct {
schema.Attr
// AutoSummarize defines the authsummarize storage parameter.
AutoSummarize bool
// PagesPerRange defines pages_per_range storage
// parameter for BRIN indexes. Defaults to 128.
PagesPerRange int64
}
// IndexInclude describes the INCLUDE clause allows specifying
// a list of column which added to the index as non-key columns.
// https://www.postgresql.org/docs/current/sql-createindex.html
IndexInclude struct {
schema.Attr
Columns []*schema.Column
}
// Concurrently describes the CONCURRENTLY clause to instruct Postgres
// to build or drop the index concurrently without blocking the current table.
// https://www.postgresql.org/docs/current/sql-createindex.html#SQL-CREATEINDEX-CONCURRENTLY
Concurrently struct {
schema.Attr
}
// NoInherit attribute defines the NO INHERIT flag for CHECK constraint.
// https://postgresql.org/docs/current/catalog-pg-constraint.html
NoInherit struct {
schema.Attr
}
// CheckColumns attribute hold the column named used by the CHECK constraints.
// This attribute is added on inspection for internal usage and has no meaning
// on migration.
CheckColumns struct {
schema.Attr
Columns []string
}
// Partition defines the spec of a partitioned table.
Partition struct {
schema.Attr
// T defines the type/strategy of the partition.
// Can be one of: RANGE, LIST, HASH.
T string
// Partition parts. The additional attributes
// on each part can be used to control collation.
Parts []*PartitionPart
// Internal info returned from pg_partitioned_table.
start, attrs, exprs string
}
// An PartitionPart represents an index part that
// can be either an expression or a column.
PartitionPart struct {
X schema.Expr
C *schema.Column
Attrs []schema.Attr
}
)
// IsUnique reports if the type is unique constraint.
func (c ConType) IsUnique() bool { return strings.ToLower(c.T) == "u" }
// IntegerType returns the underlying integer type this serial type represents.
func (s *SerialType) IntegerType() *schema.IntegerType {
t := &schema.IntegerType{T: TypeInteger}
switch s.T {
case TypeSerial2, TypeSmallSerial:
t.T = TypeSmallInt
case TypeSerial8, TypeBigSerial:
t.T = TypeBigInt
}
return t
}
// SetType sets the serial type from the given integer type.
func (s *SerialType) SetType(t *schema.IntegerType) {
switch t.T {
case TypeSmallInt, TypeInt2:
s.T = TypeSmallSerial
case TypeInteger, TypeInt4, TypeInt:
s.T = TypeSerial
case TypeBigInt, TypeInt8:
s.T = TypeBigSerial
}
}
// sequence returns the inspected name of the sequence
// or the standard name defined by postgres.
func (s *SerialType) sequence(t *schema.Table, c *schema.Column) string {
if s.SequenceName != "" {
return s.SequenceName
}
return fmt.Sprintf("%s_%s_seq", t.Name, c.Name)
}
// newIndexStorage parses and returns the index storage parameters.
func newIndexStorage(opts string) (*IndexStorageParams, error) {
params := &IndexStorageParams{}
for _, p := range strings.Split(strings.Trim(opts, "{}"), ",") {
kv := strings.Split(p, "=")
if len(kv) != 2 {
return nil, fmt.Errorf("invalid index storage parameter: %s", p)
}
switch kv[0] {
case "autosummarize":
b, err := strconv.ParseBool(kv[1])
if err != nil {
return nil, fmt.Errorf("failed parsing autosummarize %q: %w", kv[1], err)
}
params.AutoSummarize = b
case "pages_per_range":
i, err := strconv.ParseInt(kv[1], 10, 64)
if err != nil {
return nil, fmt.Errorf("failed parsing pages_per_range %q: %w", kv[1], err)
}
params.PagesPerRange = i
}
}
return params, nil
}
// reEnumType extracts the enum type and an option schema qualifier.
var reEnumType = regexp.MustCompile(`^(?:(".+"|\w+)\.)?(".+"|\w+)$`)
func newEnumType(t string, id int64) *enumType {
var (
e = &enumType{T: t, ID: id}
parts = reEnumType.FindStringSubmatch(e.T)
r = func(s string) string {
s = strings.ReplaceAll(s, `""`, `"`)
if len(s) > 1 && s[0] == '"' && s[len(s)-1] == '"' {
s = s[1 : len(s)-1]
}
return s
}
)
if len(parts) > 1 {
e.Schema = r(parts[1])
}
if len(parts) > 2 {
e.T = r(parts[2])
}
return e
}
const (
// Query to list runtime parameters.
paramsQuery = `SELECT setting FROM pg_settings WHERE name IN ('lc_collate', 'lc_ctype', 'server_version_num', 'crdb_version') ORDER BY name DESC`
// Query to list database schemas.
schemasQuery = "SELECT schema_name FROM information_schema.schemata WHERE schema_name NOT IN ('information_schema', 'pg_catalog', 'pg_toast', 'crdb_internal', 'pg_extension') AND schema_name NOT LIKE 'pg_%temp_%' ORDER BY schema_name"
// Query to list specific database schemas.
schemasQueryArgs = "SELECT schema_name FROM information_schema.schemata WHERE schema_name %s ORDER BY schema_name"
// Query to list table information.
tablesQuery = `
SELECT
t1.table_schema,
t1.table_name,
pg_catalog.obj_description(t3.oid, 'pg_class') AS comment,
t4.partattrs AS partition_attrs,
t4.partstrat AS partition_strategy,
pg_get_expr(t4.partexprs, t4.partrelid) AS partition_exprs
FROM
INFORMATION_SCHEMA.TABLES AS t1
JOIN pg_catalog.pg_namespace AS t2 ON t2.nspname = t1.table_schema
JOIN pg_catalog.pg_class AS t3 ON t3.relnamespace = t2.oid AND t3.relname = t1.table_name
LEFT JOIN pg_catalog.pg_partitioned_table AS t4 ON t4.partrelid = t3.oid
WHERE
t1.table_type = 'BASE TABLE'
AND NOT COALESCE(t3.relispartition, false)
AND t1.table_schema IN (%s)
ORDER BY
t1.table_schema, t1.table_name
`
tablesQueryArgs = `
SELECT
t1.table_schema,
t1.table_name,
pg_catalog.obj_description(t3.oid, 'pg_class') AS comment,
t4.partattrs AS partition_attrs,
t4.partstrat AS partition_strategy,
pg_get_expr(t4.partexprs, t4.partrelid) AS partition_exprs
FROM
INFORMATION_SCHEMA.TABLES AS t1
JOIN pg_catalog.pg_namespace AS t2 ON t2.nspname = t1.table_schema
JOIN pg_catalog.pg_class AS t3 ON t3.relnamespace = t2.oid AND t3.relname = t1.table_name
LEFT JOIN pg_catalog.pg_partitioned_table AS t4 ON t4.partrelid = t3.oid
WHERE
t1.table_type = 'BASE TABLE'
AND NOT COALESCE(t3.relispartition, false)
AND t1.table_schema IN (%s)
AND t1.table_name IN (%s)
ORDER BY
t1.table_schema, t1.table_name
`
// Query to list table columns.
columnsQuery = `
SELECT
t1.table_name,
t1.column_name,
t1.data_type,
pg_catalog.format_type(a.atttypid, a.atttypmod) AS format_type,
t1.is_nullable,
t1.column_default,
t1.character_maximum_length,
t1.numeric_precision,
t1.datetime_precision,
t1.numeric_scale,
t1.interval_type,
t1.character_set_name,
t1.collation_name,
t1.is_identity,
t1.identity_start,
t1.identity_increment,
(CASE WHEN t1.is_identity = 'YES' THEN (SELECT last_value FROM pg_sequences WHERE quote_ident(schemaname) || '.' || quote_ident(sequencename) = pg_get_serial_sequence(quote_ident(t1.table_schema) || '.' || quote_ident(t1.table_name), t1.column_name)) END) AS identity_last,
t1.identity_generation,
t1.generation_expression,
col_description(t3.oid, "ordinal_position") AS comment,
t4.typtype,
t4.typelem,
(CASE WHEN t4.typcategory = 'A' AND t4.typelem <> 0 THEN (SELECT t.typtype FROM pg_catalog.pg_type t WHERE t.oid = t4.typelem) END) AS elemtyp,
t4.oid
FROM
"information_schema"."columns" AS t1
JOIN pg_catalog.pg_namespace AS t2 ON t2.nspname = t1.table_schema
JOIN pg_catalog.pg_class AS t3 ON t3.relnamespace = t2.oid AND t3.relname = t1.table_name
JOIN pg_catalog.pg_attribute AS a ON a.attrelid = t3.oid AND a.attname = t1.column_name
LEFT JOIN pg_catalog.pg_type AS t4 ON t1.udt_name = t4.typname AND t4.typnamespace = t2.oid
WHERE
t1.table_schema = $1 AND t1.table_name IN (%s)
ORDER BY
t1.table_name, t1.ordinal_position
`
fksQuery = `
SELECT
t1.constraint_name,
t1.table_name,
t2.column_name,
t1.table_schema,
t3.table_name AS referenced_table_name,
t3.column_name AS referenced_column_name,
t3.table_schema AS referenced_schema_name,
t4.update_rule,
t4.delete_rule
FROM
information_schema.table_constraints t1
JOIN information_schema.key_column_usage t2
ON t1.constraint_name = t2.constraint_name
AND t1.table_schema = t2.constraint_schema
JOIN information_schema.constraint_column_usage t3
ON t1.constraint_name = t3.constraint_name
AND t1.table_schema = t3.constraint_schema
JOIN information_schema.referential_constraints t4
ON t1.constraint_name = t4.constraint_name
AND t1.table_schema = t4.constraint_schema
WHERE
t1.constraint_type = 'FOREIGN KEY'
AND t1.table_schema = $1
AND t1.table_name IN (%s)
ORDER BY
t1.constraint_name,
t2.ordinal_position
`
// Query to list table check constraints.
checksQuery = `
SELECT
rel.relname AS table_name,
t1.conname AS constraint_name,
pg_get_expr(t1.conbin, t1.conrelid) as expression,
t2.attname as column_name,
t1.conkey as column_indexes,
t1.connoinherit as no_inherit
FROM
pg_constraint t1
JOIN pg_attribute t2
ON t2.attrelid = t1.conrelid
AND t2.attnum = ANY (t1.conkey)
JOIN pg_class rel
ON rel.oid = t1.conrelid
JOIN pg_namespace nsp
ON nsp.oid = t1.connamespace
WHERE
t1.contype = 'c'
AND nsp.nspname = $1
AND rel.relname IN (%s)
ORDER BY
t1.conname, array_position(t1.conkey, t2.attnum)
`
)
var (
indexesQuery = fmt.Sprintf(indexesQueryTmpl, "(a.attname <> '' AND idx.indnatts > idx.indnkeyatts AND idx.ord > idx.indnkeyatts)", "%s")
indexesQueryNoInclude = fmt.Sprintf(indexesQueryTmpl, "false", "%s")
indexesQueryTmpl = `
SELECT
t.relname AS table_name,
i.relname AS index_name,
am.amname AS index_type,
a.attname AS column_name,
%s AS included,
idx.indisprimary AS primary,
idx.indisunique AS unique,
c.contype AS constraint_type,
pg_get_expr(idx.indpred, idx.indrelid) AS predicate,
pg_get_indexdef(idx.indexrelid, idx.ord, false) AS expression,
pg_index_column_has_property(idx.indexrelid, idx.ord, 'desc') AS desc,
pg_index_column_has_property(idx.indexrelid, idx.ord, 'nulls_first') AS nulls_first,
pg_index_column_has_property(idx.indexrelid, idx.ord, 'nulls_last') AS nulls_last,
obj_description(i.oid, 'pg_class') AS comment,
i.reloptions AS options
FROM
(
select
*,
generate_series(1,array_length(i.indkey,1)) as ord,
unnest(i.indkey) AS key
from pg_index i
) idx
JOIN pg_class i ON i.oid = idx.indexrelid
JOIN pg_class t ON t.oid = idx.indrelid
JOIN pg_namespace n ON n.oid = t.relnamespace
LEFT JOIN pg_constraint c ON idx.indexrelid = c.conindid
LEFT JOIN pg_attribute a ON (a.attrelid, a.attnum) = (idx.indrelid, idx.key)
JOIN pg_am am ON am.oid = i.relam
WHERE
n.nspname = $1
AND t.relname IN (%s)
AND COALESCE(c.contype, '') <> 'f'
ORDER BY
table_name, index_name, idx.ord
`
)
atlas-0.7.2/sql/postgres/inspect_test.go 0000664 0000000 0000000 00000165447 14314555116 0020352 0 ustar 00root root 0000000 0000000 // Copyright 2021-present The Atlas Authors. All rights reserved.
// This source code is licensed under the Apache 2.0 license found
// in the LICENSE file in the root directory of this source tree.
package postgres
import (
"context"
"fmt"
"testing"
"ariga.io/atlas/sql/internal/sqltest"
"ariga.io/atlas/sql/migrate"
"ariga.io/atlas/sql/schema"
"github.com/DATA-DOG/go-sqlmock"
"github.com/stretchr/testify/require"
)
// Single table queries used by the different tests.
var (
queryFKs = sqltest.Escape(fmt.Sprintf(fksQuery, "$2"))
queryTables = sqltest.Escape(fmt.Sprintf(tablesQuery, "$1"))
queryChecks = sqltest.Escape(fmt.Sprintf(checksQuery, "$2"))
queryColumns = sqltest.Escape(fmt.Sprintf(columnsQuery, "$2"))
queryCrdbColumns = sqltest.Escape(fmt.Sprintf(crdbColumnsQuery, "$2"))
queryIndexes = sqltest.Escape(fmt.Sprintf(indexesQuery, "$2"))
queryCrdbIndexes = sqltest.Escape(fmt.Sprintf(crdbIndexesQuery, "$2"))
)
func TestDriver_InspectTable(t *testing.T) {
tests := []struct {
name string
before func(mock)
expect func(*require.Assertions, *schema.Table, error)
}{
{
name: "column types",
before: func(m mock) {
m.tableExists("public", "users", true)
m.ExpectQuery(queryColumns).
WithArgs("public", "users").
WillReturnRows(sqltest.Rows(`
table_name | column_name | data_type | formatted | is_nullable | column_default | character_maximum_length | numeric_precision | datetime_precision | numeric_scale | interval_type | character_set_name | collation_name | is_identity | identity_start | identity_increment | identity_last | identity_generation | generation_expression | comment | typtype | typelem | elemtyp | oid
-------------+--------------+-----------------------------+---------------------|-------------+----------------------------------------+--------------------------+-------------------+--------------------+---------------+---------------------+--------------------+----------------+-------------+----------------+--------------------+------------------+---------------------+-----------------------+---------+---------+---------+---------+-------
users | id | bigint | int8 | NO | | | 64 | | 0 | | | | YES | 100 | 1 | 1 | BY DEFAULT | | | b | | | 20
users | rank | integer | int4 | YES | | | 32 | | 0 | | | | NO | | | | | | rank | b | | | 23
users | c1 | smallint | int2 | NO | 1000 | | 16 | | 0 | | | | NO | | | | | | | b | | | 21
users | c2 | bit | bit | NO | | 1 | | | | | | | NO | | | | | | | b | | | 1560
users | c3 | bit varying | varbit | NO | | 10 | | | | | | | NO | | | | | | | b | | | 1562
users | c4 | boolean | bool | NO | | | | | | | | | NO | | | | | | | b | | | 16
users | c5 | bytea | bytea | NO | | | | | | | | | NO | | | | | | | b | | | 17
users | c6 | character | bpchar | NO | | 100 | | | | | | | NO | | | | | | | b | | | 1042
users | c7 | character varying | varchar | NO | 'logged_in'::character varying | | | | | | | | NO | | | | | | | b | | | 1043
users | c8 | cidr | cidr | NO | | | | | | | | | NO | | | | | | | b | | | 650
users | c9 | circle | circle | NO | | | | | | | | | NO | | | | | | | b | | | 718
users | c10 | date | date | NO | | | | | | | | | NO | | | | | | | b | | | 1082
users | c11 | time with time zone | timetz | NO | | | | | | | | | NO | | | | | | | b | | | 1266
users | c12 | double precision | float8 | NO | | | 53 | | | | | | NO | | | | | | | b | | | 701
users | c13 | real | float4 | NO | random() | | 24 | | | | | | NO | | | | | | | b | | | 700
users | c14 | json | json | NO | '{}'::json | | | | | | | | NO | | | | | | | b | | | 114
users | c15 | jsonb | jsonb | NO | '{}'::jsonb | | | | | | | | NO | | | | | | | b | | | 3802
users | c16 | money | money | NO | | | | | | | | | NO | | | | | | | b | | | 790
users | c17 | numeric | numeric | NO | | | | | | | | | NO | | | | | | | b | | | 1700
users | c18 | numeric | numeric | NO | | | 4 | | 4 | | | | NO | | | | | | | b | | | 1700
users | c19 | integer | int4 | NO | nextval('t1_c19_seq'::regclass) | | 32 | | 0 | | | | NO | | | | | | | b | | | 23
users | c20 | uuid | uuid | NO | | | | | | | | | NO | | | | | | | b | | | 2950
users | c21 | xml | xml | NO | | | | | | | | | NO | | | | | | | b | | | 142
users | c22 | ARRAY | integer[] | YES | | | | | | | | | NO | | | | | | | b | | | 1007
users | c23 | USER-DEFINED | ltree | YES | | | | | | | | | NO | | | | | | | b | | | 16535
users | c24 | USER-DEFINED | state | NO | | | | | | | | | NO | | | | | | | e | | | 16774
users | c25 | timestamp without time zone | timestamp | NO | now() | | | 4 | | | | | NO | | | | | | | b | | | 1114
users | c26 | timestamp with time zone | timestamptz | NO | | | | 6 | | | | | NO | | | | | | | b | | | 1184
users | c27 | time without time zone | time | NO | | | | 6 | | | | | NO | | | | | | | b | | | 1266
users | c28 | int | int8 | NO | | | | 6 | | | | | NO | | | | | (c1 + c2) | | b | | | 1267
users | c29 | interval | interval | NO | | | | 6 | | | | | NO | | | | | | | b | | | 1268
users | c30 | interval | interval | NO | | | | 6 | | MONTH | | | NO | | | | | | | b | | | 1269
users | c31 | interval | interval | NO | | | | 6 | | MINUTE TO SECOND(6) | | | NO | | | | | | | b | | | 1233
users | c32 | bigint | int4 | NO | nextval('public.t1_c32_seq'::regclass) | | 32 | | 0 | | | | NO | | | | | | | b | | | 23
users | c33 | USER-DEFINED | test."status""." | NO | 'unknown'::test."status""." | | | | | | | | NO | | | | | | | e | | | 16775
users | c34 | ARRAY | state[] | NO | | | | | | | | | NO | | | | | | | b | 16774 | e | 16779
`))
m.ExpectQuery(sqltest.Escape(`SELECT enumtypid, enumlabel FROM pg_enum WHERE enumtypid IN ($1, $2)`)).
WithArgs(16774, 16775).
WillReturnRows(sqltest.Rows(`
enumtypid | enumlabel
-----------+-----------
16774 | on
16774 | off
16775 | unknown
`))
m.noIndexes()
m.noFKs()
m.noChecks()
},
expect: func(require *require.Assertions, t *schema.Table, err error) {
p := func(i int) *int { return &i }
require.NoError(err)
require.Equal("users", t.Name)
require.EqualValues([]*schema.Column{
{Name: "id", Type: &schema.ColumnType{Raw: "bigint", Type: &schema.IntegerType{T: "bigint"}}, Attrs: []schema.Attr{&Identity{Generation: "BY DEFAULT", Sequence: &Sequence{Start: 100, Increment: 1, Last: 1}}}},
{Name: "rank", Type: &schema.ColumnType{Raw: "integer", Null: true, Type: &schema.IntegerType{T: "integer"}}, Attrs: []schema.Attr{&schema.Comment{Text: "rank"}}},
{Name: "c1", Type: &schema.ColumnType{Raw: "smallint", Type: &schema.IntegerType{T: "smallint"}}, Default: &schema.Literal{V: "1000"}},
{Name: "c2", Type: &schema.ColumnType{Raw: "bit", Type: &BitType{T: "bit", Len: 1}}},
{Name: "c3", Type: &schema.ColumnType{Raw: "bit varying", Type: &BitType{T: "bit varying", Len: 10}}},
{Name: "c4", Type: &schema.ColumnType{Raw: "boolean", Type: &schema.BoolType{T: "boolean"}}},
{Name: "c5", Type: &schema.ColumnType{Raw: "bytea", Type: &schema.BinaryType{T: "bytea"}}},
{Name: "c6", Type: &schema.ColumnType{Raw: "character", Type: &schema.StringType{T: "character", Size: 100}}},
{Name: "c7", Type: &schema.ColumnType{Raw: "character varying", Type: &schema.StringType{T: "character varying"}}, Default: &schema.Literal{V: "'logged_in'"}},
{Name: "c8", Type: &schema.ColumnType{Raw: "cidr", Type: &NetworkType{T: "cidr"}}},
{Name: "c9", Type: &schema.ColumnType{Raw: "circle", Type: &schema.SpatialType{T: "circle"}}},
{Name: "c10", Type: &schema.ColumnType{Raw: "date", Type: &schema.TimeType{T: "date"}}},
{Name: "c11", Type: &schema.ColumnType{Raw: "time with time zone", Type: &schema.TimeType{T: "time with time zone", Precision: p(0)}}},
{Name: "c12", Type: &schema.ColumnType{Raw: "double precision", Type: &schema.FloatType{T: "double precision", Precision: 53}}},
{Name: "c13", Type: &schema.ColumnType{Raw: "real", Type: &schema.FloatType{T: "real", Precision: 24}}, Default: &schema.RawExpr{X: "random()"}},
{Name: "c14", Type: &schema.ColumnType{Raw: "json", Type: &schema.JSONType{T: "json"}}, Default: &schema.Literal{V: "'{}'"}},
{Name: "c15", Type: &schema.ColumnType{Raw: "jsonb", Type: &schema.JSONType{T: "jsonb"}}, Default: &schema.Literal{V: "'{}'"}},
{Name: "c16", Type: &schema.ColumnType{Raw: "money", Type: &CurrencyType{T: "money"}}},
{Name: "c17", Type: &schema.ColumnType{Raw: "numeric", Type: &schema.DecimalType{T: "numeric"}}},
{Name: "c18", Type: &schema.ColumnType{Raw: "numeric", Type: &schema.DecimalType{T: "numeric", Precision: 4, Scale: 4}}},
{Name: "c19", Type: &schema.ColumnType{Raw: "serial", Type: &SerialType{T: "serial", SequenceName: "t1_c19_seq"}}},
{Name: "c20", Type: &schema.ColumnType{Raw: "uuid", Type: &UUIDType{T: "uuid"}}},
{Name: "c21", Type: &schema.ColumnType{Raw: "xml", Type: &XMLType{T: "xml"}}},
{Name: "c22", Type: &schema.ColumnType{Raw: "ARRAY", Null: true, Type: &ArrayType{Type: &schema.IntegerType{T: "integer"}, T: "integer[]"}}},
{Name: "c23", Type: &schema.ColumnType{Raw: "USER-DEFINED", Null: true, Type: &UserDefinedType{T: "ltree"}}},
{Name: "c24", Type: &schema.ColumnType{Raw: "state", Type: &schema.EnumType{T: "state", Values: []string{"on", "off"}, Schema: t.Schema}}},
{Name: "c25", Type: &schema.ColumnType{Raw: "timestamp without time zone", Type: &schema.TimeType{T: "timestamp without time zone", Precision: p(4)}}, Default: &schema.RawExpr{X: "now()"}},
{Name: "c26", Type: &schema.ColumnType{Raw: "timestamp with time zone", Type: &schema.TimeType{T: "timestamp with time zone", Precision: p(6)}}},
{Name: "c27", Type: &schema.ColumnType{Raw: "time without time zone", Type: &schema.TimeType{T: "time without time zone", Precision: p(6)}}},
{Name: "c28", Type: &schema.ColumnType{Raw: "int", Type: &schema.IntegerType{T: "int"}}, Attrs: []schema.Attr{&schema.GeneratedExpr{Expr: "(c1 + c2)"}}},
{Name: "c29", Type: &schema.ColumnType{Raw: "interval", Type: &IntervalType{T: "interval", Precision: p(6)}}},
{Name: "c30", Type: &schema.ColumnType{Raw: "interval", Type: &IntervalType{T: "interval", F: "MONTH", Precision: p(6)}}},
{Name: "c31", Type: &schema.ColumnType{Raw: "interval", Type: &IntervalType{T: "interval", F: "MINUTE TO SECOND", Precision: p(6)}}},
{Name: "c32", Type: &schema.ColumnType{Raw: "bigserial", Type: &SerialType{T: "bigserial", SequenceName: "t1_c32_seq"}}},
{Name: "c33", Type: &schema.ColumnType{Raw: `status".`, Type: &schema.EnumType{T: `status".`, Values: []string{"unknown"}, Schema: schema.New("test")}}, Default: &schema.Literal{V: "'unknown'"}},
{Name: "c34", Type: &schema.ColumnType{Raw: "ARRAY", Type: &ArrayType{T: "state[]", Type: &schema.EnumType{T: "state", Values: []string{"on", "off"}, Schema: t.Schema}}}},
}, t.Columns)
},
},
{
name: "table indexes",
before: func(m mock) {
m.tableExists("public", "users", true)
m.ExpectQuery(queryColumns).
WithArgs("public", "users").
WillReturnRows(sqltest.Rows(`
table_name | column_name | data_type | formatted | is_nullable | column_default | character_maximum_length | numeric_precision | datetime_precision | numeric_scale | interval_type | character_set_name | collation_name | is_identity | identity_start | identity_increment | identity_last | identity_generation | generation_expression | comment | typtype | typelem | elemtyp | oid
-----------+-------------+---------------------+-----------+--------------+---------------------------------+--------------------------+-------------------+--------------------+---------------+---------------+--------------------+----------------+-------------+----------------+--------------------+------------------+---------------------+-----------------------+---------+---------+---------+---------+-------
users | id | bigint | int8 | NO | | | 64 | | 0 | | | | NO | | | | | | | b | | | 20
users | c1 | smallint | int2 | NO | | | 16 | | 0 | | | | NO | | | | | | | b | | | 21
users | parent_id | bigint | int8 | YES | | | 64 | | 0 | | | | NO | | | | | | | b | | | 22
`))
m.ExpectQuery(queryIndexes).
WithArgs("public", "users").
WillReturnRows(sqltest.Rows(`
table_name | index_name | index_type | column_name | included | primary | unique | constraint_type | predicate | expression | desc | nulls_first | nulls_last | comment | options
----------------+-----------------+-------------+-------------+----------+---------+--------+-----------------+-----------------------+---------------------------+------+-------------+------------+-----------+-----------
users | idx | hash | | f | f | f | | | "left"((c11)::text, 100) | t | t | f | boring |
users | idx1 | btree | | f | f | f | | (id <> NULL::integer) | "left"((c11)::text, 100) | t | t | f | |
users | t1_c1_key | btree | c1 | f | f | t | u | | c1 | t | t | f | |
users | t1_pkey | btree | id | f | t | t | p | | id | t | f | f | |
users | idx4 | btree | c1 | f | f | t | | | c1 | f | f | f | |
users | idx4 | btree | id | f | f | t | | | id | f | f | t | |
users | idx5 | btree | c1 | f | f | t | | | c1 | f | f | f | |
users | idx5 | btree | | f | f | t | | | coalesce(parent_id, 0) | f | f | f | |
users | idx6 | brin | c1 | f | f | t | | | | f | f | f | | {autosummarize=true,pages_per_range=2}
users | idx2 | btree | | f | f | f | | | ((c * 2)) | f | f | t | |
users | idx2 | btree | c1 | f | f | f | | | c | f | f | t | |
users | idx2 | btree | id | f | f | f | | | d | f | f | t | |
users | idx2 | btree | c1 | t | f | f | | | c | | | | |
users | idx2 | btree | parent_id | t | f | f | | | d | | | | |
`))
m.noFKs()
m.noChecks()
},
expect: func(require *require.Assertions, t *schema.Table, err error) {
require.NoError(err)
require.Equal("users", t.Name)
columns := []*schema.Column{
{Name: "id", Type: &schema.ColumnType{Raw: "bigint", Type: &schema.IntegerType{T: "bigint"}}},
{Name: "c1", Type: &schema.ColumnType{Raw: "smallint", Type: &schema.IntegerType{T: "smallint"}}},
{Name: "parent_id", Type: &schema.ColumnType{Raw: "bigint", Null: true, Type: &schema.IntegerType{T: "bigint"}}},
}
indexes := []*schema.Index{
{Name: "idx", Table: t, Attrs: []schema.Attr{&IndexType{T: "hash"}, &schema.Comment{Text: "boring"}}, Parts: []*schema.IndexPart{{SeqNo: 1, X: &schema.RawExpr{X: `"left"((c11)::text, 100)`}, Desc: true, Attrs: []schema.Attr{&IndexColumnProperty{NullsFirst: true}}}}},
{Name: "idx1", Table: t, Attrs: []schema.Attr{&IndexType{T: "btree"}, &IndexPredicate{P: `(id <> NULL::integer)`}}, Parts: []*schema.IndexPart{{SeqNo: 1, X: &schema.RawExpr{X: `"left"((c11)::text, 100)`}, Desc: true, Attrs: []schema.Attr{&IndexColumnProperty{NullsFirst: true}}}}},
{Name: "t1_c1_key", Unique: true, Table: t, Attrs: []schema.Attr{&IndexType{T: "btree"}, &ConType{T: "u"}}, Parts: []*schema.IndexPart{{SeqNo: 1, C: columns[1], Desc: true, Attrs: []schema.Attr{&IndexColumnProperty{NullsFirst: true}}}}},
{Name: "idx4", Unique: true, Table: t, Attrs: []schema.Attr{&IndexType{T: "btree"}}, Parts: []*schema.IndexPart{{SeqNo: 1, C: columns[1]}, {SeqNo: 2, C: columns[0], Attrs: []schema.Attr{&IndexColumnProperty{NullsLast: true}}}}},
{Name: "idx5", Unique: true, Table: t, Attrs: []schema.Attr{&IndexType{T: "btree"}}, Parts: []*schema.IndexPart{{SeqNo: 1, C: columns[1]}, {SeqNo: 2, X: &schema.RawExpr{X: `coalesce(parent_id, 0)`}}}},
{Name: "idx6", Unique: true, Table: t, Attrs: []schema.Attr{&IndexType{T: "brin"}, &IndexStorageParams{AutoSummarize: true, PagesPerRange: 2}}, Parts: []*schema.IndexPart{{SeqNo: 1, C: columns[1]}}},
{Name: "idx2", Unique: false, Table: t, Attrs: []schema.Attr{&IndexType{T: "btree"}, &IndexInclude{Columns: columns[1:]}}, Parts: []*schema.IndexPart{{SeqNo: 1, X: &schema.RawExpr{X: `((c * 2))`}, Attrs: []schema.Attr{&IndexColumnProperty{NullsLast: true}}}, {SeqNo: 2, C: columns[1], Attrs: []schema.Attr{&IndexColumnProperty{NullsLast: true}}}, {SeqNo: 3, C: columns[0], Attrs: []schema.Attr{&IndexColumnProperty{NullsLast: true}}}}},
}
pk := &schema.Index{
Name: "t1_pkey",
Unique: true,
Table: t,
Attrs: []schema.Attr{&IndexType{T: "btree"}, &ConType{T: "p"}},
Parts: []*schema.IndexPart{{SeqNo: 1, C: columns[0], Desc: true}},
}
columns[0].Indexes = append(columns[0].Indexes, pk, indexes[3], indexes[6])
columns[1].Indexes = indexes[2:]
require.EqualValues(columns, t.Columns)
require.EqualValues(indexes, t.Indexes)
require.EqualValues(pk, t.PrimaryKey)
},
},
{
name: "fks",
before: func(m mock) {
m.tableExists("public", "users", true)
m.ExpectQuery(queryColumns).
WithArgs("public", "users").
WillReturnRows(sqltest.Rows(`
table_name | column_name | data_type | formatted | is_nullable | column_default | character_maximum_length | numeric_precision | datetime_precision | numeric_scale | interval_type | character_set_name | collation_name | is_identity | identity_start | identity_increment | identity_last | identity_generation | generation_expression | comment | typtype | typelem | elemtyp | oid
-----------+-------------+---------------------+-----------+-------------+---------------------------------+--------------------------+-------------------+--------------------+---------------+---------------+--------------------+----------------+-------------+----------------+--------------------+------------------+---------------------+-----------------------+---------+---------+---------+---------+-------
users | id | integer | int | NO | | | 32 | | 0 | | | | NO | | | | | | | b | | | 20
users | oid | integer | int | NO | | | 32 | | 0 | | | | NO | | | | | | | b | | | 21
users | uid | integer | int | NO | | | 32 | | 0 | | | | NO | | | | | | | b | | | 21
`))
m.noIndexes()
m.ExpectQuery(queryFKs).
WithArgs("public", "users").
WillReturnRows(sqltest.Rows(`
constraint_name | table_name | column_name | table_schema | referenced_table_name | referenced_column_name | referenced_schema_name | update_rule | delete_rule
-----------------+------------+-------------+--------------+-----------------------+------------------------+------------------------+-------------+-------------
multi_column | users | id | public | t1 | gid | public | NO ACTION | CASCADE
multi_column | users | id | public | t1 | xid | public | NO ACTION | CASCADE
multi_column | users | oid | public | t1 | gid | public | NO ACTION | CASCADE
multi_column | users | oid | public | t1 | xid | public | NO ACTION | CASCADE
self_reference | users | uid | public | users | id | public | NO ACTION | CASCADE
`))
m.noChecks()
},
expect: func(require *require.Assertions, t *schema.Table, err error) {
require.NoError(err)
require.Equal("users", t.Name)
require.Equal("public", t.Schema.Name)
fks := []*schema.ForeignKey{
{Symbol: "multi_column", Table: t, OnUpdate: schema.NoAction, OnDelete: schema.Cascade, RefTable: &schema.Table{Name: "t1", Schema: t.Schema}, RefColumns: []*schema.Column{{Name: "gid"}, {Name: "xid"}}},
{Symbol: "self_reference", Table: t, OnUpdate: schema.NoAction, OnDelete: schema.Cascade, RefTable: t},
}
columns := []*schema.Column{
{Name: "id", Type: &schema.ColumnType{Raw: "integer", Type: &schema.IntegerType{T: "integer"}}, ForeignKeys: fks[0:1]},
{Name: "oid", Type: &schema.ColumnType{Raw: "integer", Type: &schema.IntegerType{T: "integer"}}, ForeignKeys: fks[0:1]},
{Name: "uid", Type: &schema.ColumnType{Raw: "integer", Type: &schema.IntegerType{T: "integer"}}, ForeignKeys: fks[1:2]},
}
fks[0].Columns = columns[:2]
fks[1].Columns = columns[2:]
fks[1].RefColumns = columns[:1]
require.EqualValues(columns, t.Columns)
require.EqualValues(fks, t.ForeignKeys)
},
},
{
name: "check",
before: func(m mock) {
m.tableExists("public", "users", true)
m.ExpectQuery(queryColumns).
WithArgs("public", "users").
WillReturnRows(sqltest.Rows(`
table_name |column_name | data_type | formatted | is_nullable | column_default | character_maximum_length | numeric_precision | datetime_precision | numeric_scale | interval_type | character_set_name | collation_name | is_identity | identity_start | identity_increment | identity_last | identity_generation | generation_expression | comment | typtype | typelem | elemtyp | oid
-----------+------------+-----------+-----------+-------------+----------------+--------------------------+-------------------+--------------------+---------------+---------------+--------------------+----------------+-------------+----------------+--------------------+------------------+---------------------+-----------------------+---------+---------+---------+---------+-----
users | c1 | integer | int4 | NO | | | 32 | | 0 | | | | NO | | | | | | | b | | | 23
users | c2 | integer | int4 | NO | | | 32 | | 0 | | | | NO | | | | | | | b | | | 23
users | c3 | integer | int4 | NO | | | 32 | | 0 | | | | NO | | | | | | | b | | | 23
`))
m.noIndexes()
m.noFKs()
m.ExpectQuery(queryChecks).
WithArgs("public", "users").
WillReturnRows(sqltest.Rows(`
table_name | constraint_name | expression | column_name | column_indexes | no_inherit
-------------+--------------------+-------------------------+-------------+----------------+----------------
users | boring | (c1 > 1) | c1 | {1} | t
users | users_c2_check | (c2 > 0) | c2 | {2} | f
users | users_c2_check1 | (c2 > 0) | c2 | {2} | f
users | users_check | ((c2 + c1) > 2) | c2 | {2,1} | f
users | users_check | ((c2 + c1) > 2) | c1 | {2,1} | f
users | users_check1 | (((c2 + c1) + c3) > 10) | c2 | {2,1,3} | f
users | users_check1 | (((c2 + c1) + c3) > 10) | c1 | {2,1,3} | f
users | users_check1 | (((c2 + c1) + c3) > 10) | c3 | {2,1,3} | f
`))
m.noChecks()
},
expect: func(require *require.Assertions, t *schema.Table, err error) {
require.NoError(err)
require.Equal("users", t.Name)
require.Equal("public", t.Schema.Name)
require.EqualValues([]*schema.Column{
{Name: "c1", Type: &schema.ColumnType{Raw: "integer", Type: &schema.IntegerType{T: "integer"}}},
{Name: "c2", Type: &schema.ColumnType{Raw: "integer", Type: &schema.IntegerType{T: "integer"}}},
{Name: "c3", Type: &schema.ColumnType{Raw: "integer", Type: &schema.IntegerType{T: "integer"}}},
}, t.Columns)
require.EqualValues([]schema.Attr{
&schema.Check{Name: "boring", Expr: "(c1 > 1)", Attrs: []schema.Attr{&CheckColumns{Columns: []string{"c1"}}, &NoInherit{}}},
&schema.Check{Name: "users_c2_check", Expr: "(c2 > 0)", Attrs: []schema.Attr{&CheckColumns{Columns: []string{"c2"}}}},
&schema.Check{Name: "users_c2_check1", Expr: "(c2 > 0)", Attrs: []schema.Attr{&CheckColumns{Columns: []string{"c2"}}}},
&schema.Check{Name: "users_check", Expr: "((c2 + c1) > 2)", Attrs: []schema.Attr{&CheckColumns{Columns: []string{"c2", "c1"}}}},
&schema.Check{Name: "users_check1", Expr: "(((c2 + c1) + c3) > 10)", Attrs: []schema.Attr{&CheckColumns{Columns: []string{"c2", "c1", "c3"}}}},
}, t.Attrs)
},
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
db, m, err := sqlmock.New()
require.NoError(t, err)
mk := mock{m}
mk.version("130000")
var drv migrate.Driver
drv, err = Open(db)
require.NoError(t, err)
mk.ExpectQuery(sqltest.Escape(fmt.Sprintf(schemasQueryArgs, "= $1"))).
WithArgs("public").
WillReturnRows(sqltest.Rows(`
schema_name
--------------------
public
`))
tt.before(mk)
s, err := drv.InspectSchema(context.Background(), "public", nil)
require.NoError(t, err)
tt.expect(require.New(t), s.Tables[0], err)
})
}
}
func TestDriver_InspectPartitionedTable(t *testing.T) {
db, m, err := sqlmock.New()
require.NoError(t, err)
mk := mock{m}
mk.version("130000")
drv, err := Open(db)
require.NoError(t, err)
mk.ExpectQuery(sqltest.Escape(fmt.Sprintf(schemasQueryArgs, "= CURRENT_SCHEMA()"))).
WillReturnRows(sqltest.Rows(`
schema_name
--------------------
public
`))
m.ExpectQuery(sqltest.Escape(fmt.Sprintf(tablesQuery, "$1"))).
WithArgs("public").
WillReturnRows(sqltest.Rows(`
table_schema | table_name | comment | partition_attrs | partition_strategy | partition_exprs
--------------+-------------+---------+-----------------+--------------------+----------------------------------------------------
public | logs1 | | | |
public | logs2 | | 1 | r |
public | logs3 | | 2 0 0 | l | (a + b), (a + (b * 2))
`))
m.ExpectQuery(sqltest.Escape(fmt.Sprintf(columnsQuery, "$2, $3, $4"))).
WithArgs("public", "logs1", "logs2", "logs3").
WillReturnRows(sqltest.Rows(`
table_name |column_name | data_type | formatted | is_nullable | column_default | character_maximum_length | numeric_precision | datetime_precision | numeric_scale | interval_type | character_set_name | collation_name | is_identity | identity_start | identity_increment | identity_last | identity_generation | generation_expression | comment | typtype | typelem | elemtyp | oid
-----------+------------+-----------+-----------+-------------+----------------+--------------------------+-------------------+--------------------+---------------+---------------+--------------------+----------------+-------------+----------------+--------------------+------------------+---------------------+-----------------------+---------+---------+---------+---------+-----
logs1 | c1 | integer | integer | NO | | | 32 | | 0 | | | | NO | | | | | | | b | | | 23
logs2 | c2 | integer | integer | NO | | | 32 | | 0 | | | | NO | | | | | | | b | | | 23
logs2 | c3 | integer | integer | NO | | | 32 | | 0 | | | | NO | | | | | | | b | | | 23
logs3 | c4 | integer | integer | NO | | | 32 | | 0 | | | | NO | | | | | | | b | | | 23
logs3 | c5 | integer | integer | NO | | | 32 | | 0 | | | | NO | | | | | | | b | | | 23
`))
m.ExpectQuery(sqltest.Escape(fmt.Sprintf(indexesQuery, "$2, $3, $4"))).
WillReturnRows(sqlmock.NewRows([]string{"table_name", "index_name", "column_name", "primary", "unique", "constraint_type", "predicate", "expression"}))
m.ExpectQuery(sqltest.Escape(fmt.Sprintf(fksQuery, "$2, $3, $4"))).
WillReturnRows(sqlmock.NewRows([]string{"constraint_name", "table_name", "column_name", "referenced_table_name", "referenced_column_name", "referenced_table_schema", "update_rule", "delete_rule"}))
m.ExpectQuery(sqltest.Escape(fmt.Sprintf(checksQuery, "$2, $3, $4"))).
WillReturnRows(sqlmock.NewRows([]string{"table_name", "constraint_name", "expression", "column_name", "column_indexes"}))
s, err := drv.InspectSchema(context.Background(), "", &schema.InspectOptions{})
require.NoError(t, err)
t1, ok := s.Table("logs1")
require.True(t, ok)
require.Empty(t, t1.Attrs)
t2, ok := s.Table("logs2")
require.True(t, ok)
require.Len(t, t2.Attrs, 1)
key := t2.Attrs[0].(*Partition)
require.Equal(t, PartitionTypeRange, key.T)
require.Equal(t, []*PartitionPart{
{C: &schema.Column{Name: "c2", Type: &schema.ColumnType{Raw: "integer", Type: &schema.IntegerType{T: "integer"}}}},
}, key.Parts)
t3, ok := s.Table("logs3")
require.True(t, ok)
require.Len(t, t3.Attrs, 1)
key = t3.Attrs[0].(*Partition)
require.Equal(t, PartitionTypeList, key.T)
require.Equal(t, []*PartitionPart{
{C: &schema.Column{Name: "c5", Type: &schema.ColumnType{Raw: "integer", Type: &schema.IntegerType{T: "integer"}}}},
{X: &schema.RawExpr{X: "(a + b)"}},
{X: &schema.RawExpr{X: "(a + (b * 2))"}},
}, key.Parts)
}
func TestDriver_InspectCRDBSchema(t *testing.T) {
db, m, err := sqlmock.New()
require.NoError(t, err)
mk := mock{m}
mk.ExpectQuery(sqltest.Escape(paramsQuery)).
WillReturnRows(sqltest.Rows(`
setting
------------
130000
en_US.utf8
en_US.utf8
cockroach
`))
drv, err := Open(db)
require.NoError(t, err)
mk.ExpectQuery(sqltest.Escape(fmt.Sprintf(schemasQueryArgs, "= $1"))).
WithArgs("public").
WillReturnRows(sqltest.Rows(`
schema_name
--------------------
public
`))
mk.tableExists("public", "users", true)
mk.ExpectQuery(queryCrdbColumns).
WithArgs("public", "users").
WillReturnRows(sqltest.Rows(`
table_name | column_name | data_type | formatted | is_nullable | column_default | character_maximum_length | numeric_precision | datetime_precision | numeric_scale | interval_type | character_set_name | collation_name | is_identity | identity_start | identity_increment | identity_last | identity_generation | generation_expression | comment | typtype | typelem | elemtyp | oid
------------+-------------+-----------+-----------+-------------+-------------------------------------------+--------------------------+-------------------+--------------------+---------------+---------------+--------------------+----------------|-------------+----------------+--------------------+------------------+-----------------------+-----------------------+---------+---------+---------+---------+-----
users | a | bigint | bigint | NO | | | 64 | | 0 | | | | NO | | | | | | | b | | | 20
users | b | bigint | bigint | NO | | | 64 | | 0 | | | | NO | | | | | | | b | | | 20
users | c | bigint | bigint | NO | | | 64 | | 0 | | | | NO | | | | | | | b | | | 20
users | d | bigint | bigint | NO | | | 64 | | 0 | | | | NO | | | | | | | b | | | 20
`))
mk.ExpectQuery(queryCrdbIndexes).
WithArgs("public", "users").
WillReturnRows(sqltest.Rows(`
table_name | index_name | column_name | primary | unique | constraint_type | create_stmt | predicate | expression | comment
------------+------------+-------------+---------+--------+-----------------+---------------------------------------------------------------------------------+-----------+------------+---------
users | idx1 | a | false | false | | CREATE INDEX idx1 ON defaultdb.public.serial USING btree (a ASC) | | a |
users | idx2 | b | false | true | u | CREATE UNIQUE INDEX idx2 ON defaultdb.public.serial USING btree (b ASC) | | b |
users | idx3 | c | false | false | | CREATE INDEX idx3 ON defaultdb.public.serial USING btree (c DESC) | | c | boring
users | idx4 | d | false | false | | CREATE INDEX idx5 ON defaultdb.public.serial USING btree (d ASC) WHERE (d < 10) | d < 10 | d |
users | idx5 | a | false | false | | CREATE INDEX idx5 ON defaultdb.public.serial USING btree (a ASC, b ASC, c ASC) | | a |
users | idx5 | b | false | false | | CREATE INDEX idx5 ON defaultdb.public.serial USING btree (a ASC, b ASC, c ASC) | | b |
users | idx5 | c | false | false | | CREATE INDEX idx5 ON defaultdb.public.serial USING btree (a ASC, b ASC, c ASC) | | c |
`))
mk.noFKs()
mk.noChecks()
s, err := drv.InspectSchema(context.Background(), "public", nil)
require.NoError(t, err)
tbl := s.Tables[0]
require.Equal(t, "users", tbl.Name)
columns := []*schema.Column{
{Name: "a", Type: &schema.ColumnType{Raw: "bigint", Type: &schema.IntegerType{T: "bigint"}}},
{Name: "b", Type: &schema.ColumnType{Raw: "bigint", Type: &schema.IntegerType{T: "bigint"}}},
{Name: "c", Type: &schema.ColumnType{Raw: "bigint", Type: &schema.IntegerType{T: "bigint"}}},
{Name: "d", Type: &schema.ColumnType{Raw: "bigint", Type: &schema.IntegerType{T: "bigint"}}},
}
indexes := []*schema.Index{
{Name: "idx1", Table: tbl, Attrs: []schema.Attr{&IndexType{T: "btree"}}, Parts: []*schema.IndexPart{{SeqNo: 1, C: columns[0]}}},
{Name: "idx2", Unique: true, Table: tbl, Attrs: []schema.Attr{&IndexType{T: "btree"}, &ConType{T: "u"}}, Parts: []*schema.IndexPart{{SeqNo: 1, C: columns[1]}}},
{Name: "idx3", Table: tbl, Attrs: []schema.Attr{&IndexType{T: "btree"}, &schema.Comment{Text: "boring"}}, Parts: []*schema.IndexPart{{SeqNo: 1, C: columns[2], Desc: true}}},
{Name: "idx4", Table: tbl, Attrs: []schema.Attr{&IndexType{T: "btree"}, &IndexPredicate{P: `d < 10`}}, Parts: []*schema.IndexPart{{SeqNo: 1, C: columns[3]}}},
{Name: "idx5", Table: tbl, Attrs: []schema.Attr{&IndexType{T: "btree"}}, Parts: []*schema.IndexPart{{SeqNo: 1, C: columns[0]}, {SeqNo: 2, C: columns[1]}, {SeqNo: 3, C: columns[2]}}},
}
columns[0].Indexes = []*schema.Index{indexes[0], indexes[4]}
columns[1].Indexes = []*schema.Index{indexes[1], indexes[4]}
columns[2].Indexes = []*schema.Index{indexes[2], indexes[4]}
columns[3].Indexes = []*schema.Index{indexes[3]}
require.EqualValues(t, columns, tbl.Columns)
require.EqualValues(t, indexes, tbl.Indexes)
}
func TestDriver_InspectSchema(t *testing.T) {
db, m, err := sqlmock.New()
require.NoError(t, err)
mk := mock{m}
mk.version("130000")
drv, err := Open(db)
require.NoError(t, err)
mk.ExpectQuery(sqltest.Escape(fmt.Sprintf(schemasQueryArgs, "= CURRENT_SCHEMA()"))).
WillReturnRows(sqltest.Rows(`
schema_name
--------------------
test
`))
m.ExpectQuery(sqltest.Escape(fmt.Sprintf(tablesQuery, "$1"))).
WithArgs("test").
WillReturnRows(sqlmock.NewRows([]string{"table_schema", "table_name", "comment", "partition_attrs", "partition_strategy", "partition_exprs"}))
s, err := drv.InspectSchema(context.Background(), "", &schema.InspectOptions{})
require.NoError(t, err)
require.EqualValues(t, func() *schema.Schema {
r := &schema.Realm{
Schemas: []*schema.Schema{
{
Name: "test",
},
},
// Server default configuration.
Attrs: []schema.Attr{
&schema.Collation{
V: "en_US.utf8",
},
&CType{
V: "en_US.utf8",
},
},
}
r.Schemas[0].Realm = r
return r.Schemas[0]
}(), s)
}
func TestDriver_Realm(t *testing.T) {
db, m, err := sqlmock.New()
require.NoError(t, err)
mk := mock{m}
mk.version("130000")
drv, err := Open(db)
require.NoError(t, err)
mk.ExpectQuery(sqltest.Escape(schemasQuery)).
WillReturnRows(sqltest.Rows(`
schema_name
--------------------
test
public
`))
m.ExpectQuery(sqltest.Escape(fmt.Sprintf(tablesQuery, "$1, $2"))).
WithArgs("test", "public").
WillReturnRows(sqlmock.NewRows([]string{"table_schema", "table_name", "comment", "partition_attrs", "partition_strategy", "partition_exprs"}))
realm, err := drv.InspectRealm(context.Background(), &schema.InspectRealmOption{})
require.NoError(t, err)
require.EqualValues(t, func() *schema.Realm {
r := &schema.Realm{
Schemas: []*schema.Schema{
{
Name: "test",
},
{
Name: "public",
},
},
// Server default configuration.
Attrs: []schema.Attr{
&schema.Collation{
V: "en_US.utf8",
},
&CType{
V: "en_US.utf8",
},
},
}
r.Schemas[0].Realm = r
r.Schemas[1].Realm = r
return r
}(), realm)
mk.ExpectQuery(sqltest.Escape(fmt.Sprintf(schemasQueryArgs, "IN ($1, $2)"))).
WithArgs("test", "public").
WillReturnRows(sqltest.Rows(`
schema_name
--------------------
test
public
`))
m.ExpectQuery(sqltest.Escape(fmt.Sprintf(tablesQuery, "$1, $2"))).
WithArgs("test", "public").
WillReturnRows(sqlmock.NewRows([]string{"table_schema", "table_name", "comment", "partition_attrs", "partition_strategy", "partition_exprs"}))
realm, err = drv.InspectRealm(context.Background(), &schema.InspectRealmOption{Schemas: []string{"test", "public"}})
require.NoError(t, err)
require.EqualValues(t, func() *schema.Realm {
r := &schema.Realm{
Schemas: []*schema.Schema{
{
Name: "test",
},
{
Name: "public",
},
},
// Server default configuration.
Attrs: []schema.Attr{
&schema.Collation{
V: "en_US.utf8",
},
&CType{
V: "en_US.utf8",
},
},
}
r.Schemas[0].Realm = r
r.Schemas[1].Realm = r
return r
}(), realm)
mk.ExpectQuery(sqltest.Escape(fmt.Sprintf(schemasQueryArgs, "= $1"))).
WithArgs("test").
WillReturnRows(sqltest.Rows(`
schema_name
--------------------
test
`))
m.ExpectQuery(sqltest.Escape(fmt.Sprintf(tablesQuery, "$1"))).
WithArgs("test").
WillReturnRows(sqlmock.NewRows([]string{"table_schema", "table_name", "comment", "partition_attrs", "partition_strategy", "partition_exprs"}))
realm, err = drv.InspectRealm(context.Background(), &schema.InspectRealmOption{Schemas: []string{"test"}})
require.NoError(t, err)
require.EqualValues(t, func() *schema.Realm {
r := &schema.Realm{
Schemas: []*schema.Schema{
{
Name: "test",
},
},
// Server default configuration.
Attrs: []schema.Attr{
&schema.Collation{
V: "en_US.utf8",
},
&CType{
V: "en_US.utf8",
},
},
}
r.Schemas[0].Realm = r
return r
}(), realm)
}
func TestInspectMode_InspectRealm(t *testing.T) {
db, m, err := sqlmock.New()
require.NoError(t, err)
mk := mock{m}
mk.version("130000")
mk.ExpectQuery(sqltest.Escape(schemasQuery)).
WillReturnRows(sqltest.Rows(`
schema_name
--------------------
test
public
`))
drv, err := Open(db)
realm, err := drv.InspectRealm(context.Background(), &schema.InspectRealmOption{Mode: schema.InspectSchemas})
require.NoError(t, err)
require.EqualValues(t, func() *schema.Realm {
r := &schema.Realm{
Schemas: []*schema.Schema{
{
Name: "test",
},
{
Name: "public",
},
},
// Server default configuration.
Attrs: []schema.Attr{
&schema.Collation{
V: "en_US.utf8",
},
&CType{
V: "en_US.utf8",
},
},
}
r.Schemas[0].Realm = r
r.Schemas[1].Realm = r
return r
}(), realm)
}
type mock struct {
sqlmock.Sqlmock
}
func (m mock) version(version string) {
m.ExpectQuery(sqltest.Escape(paramsQuery)).
WillReturnRows(sqltest.Rows(`
setting
------------
` + version + `
en_US.utf8
en_US.utf8
`))
}
func (m mock) tableExists(schema, table string, exists bool) {
rows := sqlmock.NewRows([]string{"table_schema", "table_name", "table_comment", "partition_attrs", "partition_strategy", "partition_exprs"})
if exists {
rows.AddRow(schema, table, nil, nil, nil, nil)
}
m.ExpectQuery(queryTables).
WithArgs(schema).
WillReturnRows(rows)
}
func (m mock) noIndexes() {
m.ExpectQuery(queryIndexes).
WillReturnRows(sqlmock.NewRows([]string{"table_name", "index_name", "column_name", "primary", "unique", "constraint_type", "predicate", "expression", "options"}))
}
func (m mock) noFKs() {
m.ExpectQuery(queryFKs).
WillReturnRows(sqlmock.NewRows([]string{"constraint_name", "table_name", "column_name", "referenced_table_name", "referenced_column_name", "referenced_table_schema", "update_rule", "delete_rule"}))
}
func (m mock) noChecks() {
m.ExpectQuery(queryChecks).
WillReturnRows(sqlmock.NewRows([]string{"table_name", "constraint_name", "expression", "column_name", "column_indexes"}))
}
atlas-0.7.2/sql/postgres/migrate.go 0000664 0000000 0000000 00000106600 14314555116 0017260 0 ustar 00root root 0000000 0000000 // Copyright 2021-present The Atlas Authors. All rights reserved.
// This source code is licensed under the Apache 2.0 license found
// in the LICENSE file in the root directory of this source tree.
package postgres
import (
"context"
"errors"
"fmt"
"strconv"
"strings"
"ariga.io/atlas/sql/internal/sqlx"
"ariga.io/atlas/sql/migrate"
"ariga.io/atlas/sql/schema"
)
// A planApply provides migration capabilities for schema elements.
type planApply struct{ conn }
// PlanChanges returns a migration plan for the given schema changes.
func (p *planApply) PlanChanges(ctx context.Context, name string, changes []schema.Change, opts ...migrate.PlanOption) (*migrate.Plan, error) {
s := &state{
conn: p.conn,
Plan: migrate.Plan{
Name: name,
Reversible: true,
Transactional: true,
},
created: make(map[string]*schema.EnumType),
altered: make(map[string]*schema.EnumType),
dropped: make(map[string]*schema.EnumType),
}
for _, o := range opts {
o(&s.PlanOptions)
}
if err := s.plan(ctx, changes); err != nil {
return nil, err
}
for _, c := range s.Changes {
if c.Reverse == "" {
s.Reversible = false
}
}
return &s.Plan, nil
}
// ApplyChanges applies the changes on the database. An error is returned
// if the driver is unable to produce a plan to do so, or one of the statements
// is failed or unsupported.
func (p *planApply) ApplyChanges(ctx context.Context, changes []schema.Change, opts ...migrate.PlanOption) error {
return sqlx.ApplyChanges(ctx, changes, p, opts...)
}
// state represents the state of a planning. It is not part of
// planApply so that multiple planning/applying can be called
// in parallel.
type state struct {
conn
migrate.Plan
migrate.PlanOptions
// Track the enums that were created, altered and
// dropped, in this phase to avoid duplicate updates.
created, altered, dropped map[string]*schema.EnumType
}
// Exec executes the changes on the database. An error is returned
// if one of the operations fail, or a change is not supported.
func (s *state) plan(ctx context.Context, changes []schema.Change) error {
if s.SchemaQualifier != nil {
if err := sqlx.CheckChangesScope(changes); err != nil {
return err
}
}
planned := s.topLevel(changes)
planned, err := sqlx.DetachCycles(planned)
if err != nil {
return err
}
for _, c := range planned {
switch c := c.(type) {
case *schema.AddTable:
err = s.addTable(ctx, c)
case *schema.DropTable:
s.dropTable(c)
case *schema.ModifyTable:
err = s.modifyTable(ctx, c)
case *schema.RenameTable:
s.renameTable(c)
default:
err = fmt.Errorf("unsupported change %T", c)
}
if err != nil {
return err
}
}
return nil
}
// topLevel executes first the changes for creating or dropping schemas (top-level schema elements).
func (s *state) topLevel(changes []schema.Change) []schema.Change {
planned := make([]schema.Change, 0, len(changes))
for _, c := range changes {
switch c := c.(type) {
case *schema.AddSchema:
b := s.Build("CREATE SCHEMA")
if sqlx.Has(c.Extra, &schema.IfNotExists{}) {
b.P("IF NOT EXISTS")
}
b.Ident(c.S.Name)
s.append(&migrate.Change{
Cmd: b.String(),
Source: c,
Reverse: s.Build("DROP SCHEMA").Ident(c.S.Name).P("CASCADE").String(),
Comment: fmt.Sprintf("Add new schema named %q", c.S.Name),
})
case *schema.DropSchema:
b := s.Build("DROP SCHEMA")
if sqlx.Has(c.Extra, &schema.IfExists{}) {
b.P("IF EXISTS")
}
b.Ident(c.S.Name).P("CASCADE")
s.append(&migrate.Change{
Cmd: b.String(),
Source: c,
Comment: fmt.Sprintf("Drop schema named %q", c.S.Name),
})
default:
planned = append(planned, c)
}
}
return planned
}
// addTable builds and executes the query for creating a table in a schema.
func (s *state) addTable(ctx context.Context, add *schema.AddTable) error {
// Create enum types before using them in the `CREATE TABLE` statement.
if err := s.mayAddEnums(ctx, add.T, add.T.Columns...); err != nil {
return err
}
var (
errs []string
b = s.Build("CREATE TABLE")
)
if sqlx.Has(add.Extra, &schema.IfNotExists{}) {
b.P("IF NOT EXISTS")
}
b.Table(add.T)
b.Wrap(func(b *sqlx.Builder) {
b.MapComma(add.T.Columns, func(i int, b *sqlx.Builder) {
if err := s.column(b, add.T, add.T.Columns[i]); err != nil {
errs = append(errs, err.Error())
}
})
if pk := add.T.PrimaryKey; pk != nil {
b.Comma().P("PRIMARY KEY")
s.indexParts(b, pk.Parts)
}
if len(add.T.ForeignKeys) > 0 {
b.Comma()
s.fks(b, add.T.ForeignKeys...)
}
for _, attr := range add.T.Attrs {
if c, ok := attr.(*schema.Check); ok {
b.Comma()
check(b, c)
}
}
})
if p := (Partition{}); sqlx.Has(add.T.Attrs, &p) {
s, err := formatPartition(p)
if err != nil {
errs = append(errs, err.Error())
}
b.P(s)
}
if len(errs) > 0 {
return fmt.Errorf("create table %q: %s", add.T.Name, strings.Join(errs, ", "))
}
s.append(&migrate.Change{
Cmd: b.String(),
Source: add,
Comment: fmt.Sprintf("create %q table", add.T.Name),
Reverse: s.Build("DROP TABLE").Table(add.T).String(),
})
s.addIndexes(add.T, add.T.Indexes...)
s.addComments(add.T)
return nil
}
// dropTable builds and executes the query for dropping a table from a schema.
func (s *state) dropTable(drop *schema.DropTable) {
b := s.Build("DROP TABLE")
if sqlx.Has(drop.Extra, &schema.IfExists{}) {
b.P("IF EXISTS")
}
b.Table(drop.T)
s.append(&migrate.Change{
Cmd: b.String(),
Source: drop,
Comment: fmt.Sprintf("drop %q table", drop.T.Name),
})
}
// modifyTable builds the statements that bring the table into its modified state.
func (s *state) modifyTable(ctx context.Context, modify *schema.ModifyTable) error {
var (
alter []schema.Change
addI, dropI []*schema.Index
changes []*migrate.Change
)
for _, change := range skipAutoChanges(modify.Changes) {
switch change := change.(type) {
case *schema.AddAttr, *schema.ModifyAttr:
from, to, err := commentChange(change)
if err != nil {
return err
}
changes = append(changes, s.tableComment(modify.T, to, from))
case *schema.DropAttr:
return fmt.Errorf("unsupported change type: %T", change)
case *schema.AddIndex:
if c := (schema.Comment{}); sqlx.Has(change.I.Attrs, &c) {
changes = append(changes, s.indexComment(modify.T, change.I, c.Text, ""))
}
addI = append(addI, change.I)
case *schema.DropIndex:
// Unlike DROP INDEX statements that are executed separately,
// DROP CONSTRAINT are added to the ALTER TABLE statement below.
if isUniqueConstraint(change.I) {
alter = append(alter, change)
} else {
dropI = append(dropI, change.I)
}
case *schema.ModifyIndex:
k := change.Change
if change.Change.Is(schema.ChangeComment) {
from, to, err := commentChange(sqlx.CommentDiff(change.From.Attrs, change.To.Attrs))
if err != nil {
return err
}
changes = append(changes, s.indexComment(modify.T, change.To, to, from))
// If only the comment of the index was changed.
if k &= ^schema.ChangeComment; k.Is(schema.NoChange) {
continue
}
}
// Index modification requires rebuilding the index.
addI = append(addI, change.To)
dropI = append(dropI, change.From)
case *schema.RenameIndex:
changes = append(changes, &migrate.Change{
Source: change,
Comment: fmt.Sprintf("rename an index from %q to %q", change.From.Name, change.To.Name),
Cmd: s.Build("ALTER INDEX").Ident(change.From.Name).P("RENAME TO").Ident(change.To.Name).String(),
Reverse: s.Build("ALTER INDEX").Ident(change.To.Name).P("RENAME TO").Ident(change.From.Name).String(),
})
case *schema.ModifyForeignKey:
// Foreign-key modification is translated into 2 steps.
// Dropping the current foreign key and creating a new one.
alter = append(alter, &schema.DropForeignKey{
F: change.From,
}, &schema.AddForeignKey{
F: change.To,
})
case *schema.AddColumn:
if err := s.mayAddEnums(ctx, modify.T, change.C); err != nil {
return err
}
if c := (schema.Comment{}); sqlx.Has(change.C.Attrs, &c) {
changes = append(changes, s.columnComment(modify.T, change.C, c.Text, ""))
}
alter = append(alter, change)
case *schema.ModifyColumn:
k := change.Change
if change.Change.Is(schema.ChangeComment) {
from, to, err := commentChange(sqlx.CommentDiff(change.From.Attrs, change.To.Attrs))
if err != nil {
return err
}
changes = append(changes, s.columnComment(modify.T, change.To, to, from))
// If only the comment of the column was changed.
if k &= ^schema.ChangeComment; k.Is(schema.NoChange) {
continue
}
}
from, ok1 := hasEnumType(change.From)
to, ok2 := hasEnumType(change.To)
switch {
// Enum was changed (underlying values).
case ok1 && ok2 && s.enumIdent(modify.T.Schema, from) == s.enumIdent(modify.T.Schema, to):
if err := s.alterEnum(modify.T, from, to); err != nil {
return err
}
// If only the enum values were changed,
// there is no need to ALTER the table.
if k == schema.ChangeType {
continue
}
// Enum was added or changed.
case !ok1 && ok2 ||
ok1 && ok2 && s.enumIdent(modify.T.Schema, from) != s.enumIdent(modify.T.Schema, to):
if err := s.mayAddEnums(ctx, modify.T, change.To); err != nil {
return err
}
}
alter = append(alter, &schema.ModifyColumn{To: change.To, From: change.From, Change: k})
case *schema.RenameColumn:
// "RENAME COLUMN" cannot be combined with other alterations.
b := s.Build("ALTER TABLE").Table(modify.T).P("RENAME COLUMN")
r := b.Clone()
changes = append(changes, &migrate.Change{
Source: change,
Comment: fmt.Sprintf("rename a column from %q to %q", change.From.Name, change.To.Name),
Cmd: b.Ident(change.From.Name).P("TO").Ident(change.To.Name).String(),
Reverse: r.Ident(change.To.Name).P("TO").Ident(change.From.Name).String(),
})
default:
alter = append(alter, change)
}
}
s.dropIndexes(modify.T, dropI...)
if len(alter) > 0 {
if err := s.alterTable(modify.T, alter); err != nil {
return err
}
}
s.addIndexes(modify.T, addI...)
s.append(changes...)
return nil
}
// alterTable modifies the given table by executing on it a list of changes in one SQL statement.
func (s *state) alterTable(t *schema.Table, changes []schema.Change) error {
var (
reverse []schema.Change
reversible = true
)
build := func(alter *alterChange, changes []schema.Change) (string, error) {
b := s.Build("ALTER TABLE").Table(t)
err := b.MapCommaErr(changes, func(i int, b *sqlx.Builder) error {
switch change := changes[i].(type) {
case *schema.AddColumn:
b.P("ADD COLUMN")
if err := s.column(b, t, change.C); err != nil {
return err
}
reverse = append(reverse, &schema.DropColumn{C: change.C})
case *schema.ModifyColumn:
if err := s.alterColumn(b, alter, t, change); err != nil {
return err
}
if change.Change.Is(schema.ChangeGenerated) {
reversible = false
}
reverse = append(reverse, &schema.ModifyColumn{
From: change.To,
To: change.From,
Change: change.Change & ^schema.ChangeGenerated,
})
toE, toHas := hasEnumType(change.To)
fromE, fromHas := hasEnumType(change.From)
// In case the enum was dropped or replaced with a different one.
if fromHas && !toHas || fromHas && toHas && s.enumIdent(t.Schema, fromE) != s.enumIdent(t.Schema, toE) {
if err := s.mayDropEnum(alter, t.Schema, fromE); err != nil {
return err
}
}
case *schema.DropColumn:
b.P("DROP COLUMN").Ident(change.C.Name)
reverse = append(reverse, &schema.AddColumn{C: change.C})
if e, ok := hasEnumType(change.C); ok {
if err := s.mayDropEnum(alter, t.Schema, e); err != nil {
return err
}
}
case *schema.AddIndex:
b.P("ADD CONSTRAINT").Ident(change.I.Name).P("UNIQUE")
s.indexParts(b, change.I.Parts)
// Skip reversing this operation as it is the inverse of
// the operation below and should not be used besides this.
case *schema.DropIndex:
b.P("DROP CONSTRAINT").Ident(change.I.Name)
reverse = append(reverse, &schema.AddIndex{I: change.I})
case *schema.AddForeignKey:
b.P("ADD")
s.fks(b, change.F)
reverse = append(reverse, &schema.DropForeignKey{F: change.F})
case *schema.DropForeignKey:
b.P("DROP CONSTRAINT").Ident(change.F.Symbol)
reverse = append(reverse, &schema.AddForeignKey{F: change.F})
case *schema.AddCheck:
check(b.P("ADD"), change.C)
// Reverse operation is supported if
// the constraint name is not generated.
if reversible = reversible && change.C.Name != ""; reversible {
reverse = append(reverse, &schema.DropCheck{C: change.C})
}
case *schema.DropCheck:
b.P("DROP CONSTRAINT").Ident(change.C.Name)
reverse = append(reverse, &schema.AddCheck{C: change.C})
case *schema.ModifyCheck:
switch {
case change.From.Name == "":
return errors.New("cannot modify unnamed check constraint")
case change.From.Name != change.To.Name:
return fmt.Errorf("mismatch check constraint names: %q != %q", change.From.Name, change.To.Name)
case change.From.Expr != change.To.Expr,
sqlx.Has(change.From.Attrs, &NoInherit{}) && !sqlx.Has(change.To.Attrs, &NoInherit{}),
!sqlx.Has(change.From.Attrs, &NoInherit{}) && sqlx.Has(change.To.Attrs, &NoInherit{}):
b.P("DROP CONSTRAINT").Ident(change.From.Name).Comma().P("ADD")
check(b, change.To)
default:
return errors.New("unknown check constraint change")
}
reverse = append(reverse, &schema.ModifyCheck{
From: change.To,
To: change.From,
})
}
return nil
})
if err != nil {
return "", err
}
return b.String(), nil
}
cmd := &alterChange{}
stmt, err := build(cmd, changes)
if err != nil {
return fmt.Errorf("alter table %q: %v", t.Name, err)
}
cmd.main = &migrate.Change{
Cmd: stmt,
Source: &schema.ModifyTable{
T: t,
Changes: changes,
},
Comment: fmt.Sprintf("modify %q table", t.Name),
}
if reversible {
// Changes should be reverted in
// a reversed order they were created.
sqlx.ReverseChanges(reverse)
if cmd.main.Reverse, err = build(&alterChange{}, reverse); err != nil {
return fmt.Errorf("reverse alter table %q: %v", t.Name, err)
}
}
cmd.append(s)
return nil
}
// alterChange describes an alter table migrate.Change where its main command
// can be supported by additional statements before and after it is executed.
type alterChange struct {
main *migrate.Change
before, after []*migrate.Change
}
func (a *alterChange) append(s *state) {
s.append(a.before...)
s.append(a.main)
s.append(a.after...)
}
func (s *state) alterColumn(b *sqlx.Builder, alter *alterChange, t *schema.Table, c *schema.ModifyColumn) error {
for k := c.Change; !k.Is(schema.NoChange); {
b.P("ALTER COLUMN").Ident(c.To.Name)
switch {
case k.Is(schema.ChangeType):
if err := s.alterType(b, alter, t, c); err != nil {
return err
}
k &= ^schema.ChangeType
case k.Is(schema.ChangeNull) && c.To.Type.Null:
if t, ok := c.To.Type.Type.(*SerialType); ok {
return fmt.Errorf("NOT NULL constraint is required for %s column %q", t.T, c.To.Name)
}
b.P("DROP NOT NULL")
k &= ^schema.ChangeNull
case k.Is(schema.ChangeNull) && !c.To.Type.Null:
b.P("SET NOT NULL")
k &= ^schema.ChangeNull
case k.Is(schema.ChangeDefault) && c.To.Default == nil:
b.P("DROP DEFAULT")
k &= ^schema.ChangeDefault
case k.Is(schema.ChangeDefault) && c.To.Default != nil:
s.columnDefault(b.P("SET"), c.To)
k &= ^schema.ChangeDefault
case k.Is(schema.ChangeAttr):
toI, ok := identity(c.To.Attrs)
if !ok {
return fmt.Errorf("unexpected attribute change (expect IDENTITY): %v", c.To.Attrs)
}
// The syntax for altering identity columns is identical to sequence_options.
// https://www.postgresql.org/docs/current/sql-altersequence.html
b.P("SET GENERATED", toI.Generation, "SET START WITH", strconv.FormatInt(toI.Sequence.Start, 10), "SET INCREMENT BY", strconv.FormatInt(toI.Sequence.Increment, 10))
// Skip SEQUENCE RESTART in case the "start value" is less than the "current value" in one
// of the states (inspected and desired), because this function is used for both UP and DOWN.
if fromI, ok := identity(c.From.Attrs); (!ok || fromI.Sequence.Last < toI.Sequence.Start) && toI.Sequence.Last < toI.Sequence.Start {
b.P("RESTART")
}
k &= ^schema.ChangeAttr
case k.Is(schema.ChangeGenerated):
if sqlx.Has(c.To.Attrs, &schema.GeneratedExpr{}) {
return fmt.Errorf("unexpected generation expression change (expect DROP EXPRESSION): %v", c.To.Attrs)
}
b.P("DROP EXPRESSION")
k &= ^schema.ChangeGenerated
default: // e.g. schema.ChangeComment.
return fmt.Errorf("unexpected column change: %d", k)
}
if !k.Is(schema.NoChange) {
b.Comma()
}
}
return nil
}
// alterType appends the clause(s) to alter the column type and assuming the
// "ALTER COLUMN " was called before by the alterColumn function.
func (s *state) alterType(b *sqlx.Builder, alter *alterChange, t *schema.Table, c *schema.ModifyColumn) error {
// Commands for creating and dropping serial sequences.
createDropSeq := func(st *SerialType) (string, string, string) {
seq := fmt.Sprintf(`%s%q`, s.schemaPrefix(t.Schema), st.sequence(t, c.To))
drop := s.Build("DROP SEQUENCE IF EXISTS").P(seq).String()
create := s.Build("CREATE SEQUENCE IF NOT EXISTS").P(seq, "OWNED BY").
P(fmt.Sprintf(`%s%q.%q`, s.schemaPrefix(t.Schema), t.Name, c.To.Name)).
String()
return create, drop, seq
}
toS, toHas := c.To.Type.Type.(*SerialType)
fromS, fromHas := c.From.Type.Type.(*SerialType)
switch {
// Sequence was dropped.
case fromHas && !toHas:
b.P("DROP DEFAULT")
create, drop, _ := createDropSeq(fromS)
// Sequence should be deleted after it was dropped
// from the DEFAULT value.
alter.after = append(alter.after, &migrate.Change{
Source: c,
Comment: fmt.Sprintf("drop sequence used by serial column %q", c.From.Name),
Cmd: drop,
Reverse: create,
})
toT, err := FormatType(c.To.Type.Type)
if err != nil {
return err
}
fromT, err := FormatType(fromS.IntegerType())
if err != nil {
return err
}
// Underlying type was changed. e.g. serial to bigint.
if toT != fromT {
b.Comma().P("ALTER COLUMN").Ident(c.To.Name).P("TYPE", toT)
}
// Sequence was added.
case !fromHas && toHas:
create, drop, seq := createDropSeq(toS)
// Sequence should be created before it is used by the
// column DEFAULT value.
alter.before = append(alter.before, &migrate.Change{
Source: c,
Comment: fmt.Sprintf("create sequence for serial column %q", c.To.Name),
Cmd: create,
Reverse: drop,
})
b.P("SET DEFAULT", fmt.Sprintf("nextval('%s')", seq))
toT, err := FormatType(toS.IntegerType())
if err != nil {
return err
}
fromT, err := FormatType(c.From.Type.Type)
if err != nil {
return err
}
// Underlying type was changed. e.g. integer to bigserial (bigint).
if toT != fromT {
b.Comma().P("ALTER COLUMN").Ident(c.To.Name).P("TYPE", toT)
}
// Serial type was changed. e.g. serial to bigserial.
case fromHas && toHas:
f, err := FormatType(toS.IntegerType())
if err != nil {
return err
}
b.P("TYPE", f)
default:
var (
f string
err error
)
if e, ok := c.To.Type.Type.(*schema.EnumType); ok {
f = s.enumIdent(t.Schema, e)
} else if f, err = FormatType(c.To.Type.Type); err != nil {
return err
}
b.P("TYPE", f)
}
if collate := (schema.Collation{}); sqlx.Has(c.To.Attrs, &collate) {
b.P("COLLATE", collate.V)
}
return nil
}
func (s *state) renameTable(c *schema.RenameTable) {
s.append(&migrate.Change{
Source: c,
Comment: fmt.Sprintf("rename a table from %q to %q", c.From.Name, c.To.Name),
Cmd: s.Build("ALTER TABLE").Table(c.From).P("RENAME TO").Table(c.To).String(),
Reverse: s.Build("ALTER TABLE").Table(c.To).P("RENAME TO").Table(c.From).String(),
})
}
func (s *state) addComments(t *schema.Table) {
var c schema.Comment
if sqlx.Has(t.Attrs, &c) && c.Text != "" {
s.append(s.tableComment(t, c.Text, ""))
}
for i := range t.Columns {
if sqlx.Has(t.Columns[i].Attrs, &c) && c.Text != "" {
s.append(s.columnComment(t, t.Columns[i], c.Text, ""))
}
}
for i := range t.Indexes {
if sqlx.Has(t.Indexes[i].Attrs, &c) && c.Text != "" {
s.append(s.indexComment(t, t.Indexes[i], c.Text, ""))
}
}
}
func (s *state) tableComment(t *schema.Table, to, from string) *migrate.Change {
b := s.Build("COMMENT ON TABLE").Table(t).P("IS")
return &migrate.Change{
Cmd: b.Clone().P(quote(to)).String(),
Comment: fmt.Sprintf("set comment to table: %q", t.Name),
Reverse: b.Clone().P(quote(from)).String(),
}
}
func (s *state) columnComment(t *schema.Table, c *schema.Column, to, from string) *migrate.Change {
b := s.Build("COMMENT ON COLUMN").Table(t)
b.WriteByte('.')
b.Ident(c.Name).P("IS")
return &migrate.Change{
Cmd: b.Clone().P(quote(to)).String(),
Comment: fmt.Sprintf("set comment to column: %q on table: %q", c.Name, t.Name),
Reverse: b.Clone().P(quote(from)).String(),
}
}
func (s *state) indexComment(t *schema.Table, idx *schema.Index, to, from string) *migrate.Change {
b := s.Build("COMMENT ON INDEX").Ident(idx.Name).P("IS")
return &migrate.Change{
Cmd: b.Clone().P(quote(to)).String(),
Comment: fmt.Sprintf("set comment to index: %q on table: %q", idx.Name, t.Name),
Reverse: b.Clone().P(quote(from)).String(),
}
}
func (s *state) dropIndexes(t *schema.Table, indexes ...*schema.Index) {
rs := &state{conn: s.conn}
rs.addIndexes(t, indexes...)
for i, idx := range indexes {
s.append(&migrate.Change{
Cmd: rs.Changes[i].Reverse,
Comment: fmt.Sprintf("drop index %q from table: %q", idx.Name, t.Name),
Reverse: rs.Changes[i].Cmd,
})
}
}
func (s *state) mayAddEnums(ctx context.Context, t *schema.Table, columns ...*schema.Column) error {
for _, c := range columns {
e, ok := hasEnumType(c)
if !ok {
continue
}
if e.T == "" {
return fmt.Errorf("missing enum name for column %q", c.Name)
}
if exists, err := s.enumExists(ctx, t.Schema, e); err != nil {
return err
} else if exists {
// Enum exists and was not created
// on this migration phase.
continue
}
name := s.enumIdent(t.Schema, e)
if prev, ok := s.created[name]; ok {
if !sqlx.ValuesEqual(prev.Values, e.Values) {
return fmt.Errorf("enum type %s has inconsistent desired state: %q != %q", name, prev.Values, e.Values)
}
continue
}
s.created[name] = e
create, drop := s.createDropEnum(t.Schema, e)
s.append(&migrate.Change{
Cmd: create,
Reverse: drop,
Comment: fmt.Sprintf("create enum type %q", e.T),
})
}
return nil
}
func (s *state) alterEnum(t *schema.Table, from, to *schema.EnumType) error {
if len(from.Values) > len(to.Values) {
return fmt.Errorf("dropping enum (%q) value is not supported", from.T)
}
for i := range from.Values {
if from.Values[i] != to.Values[i] {
return fmt.Errorf("replacing or reordering enum (%q) value is not supported: %q != %q", to.T, to.Values, from.Values)
}
}
name := s.enumIdent(t.Schema, from)
if prev, ok := s.altered[name]; ok {
if !sqlx.ValuesEqual(prev.Values, to.Values) {
return fmt.Errorf("enum type %s has inconsistent desired state: %q != %q", name, prev.Values, to.Values)
}
return nil
}
s.altered[name] = to
for _, v := range to.Values[len(from.Values):] {
s.append(&migrate.Change{
Cmd: s.Build("ALTER TYPE").P(name, "ADD VALUE", quote(v)).String(),
Comment: fmt.Sprintf("add value to enum type: %q", from.T),
})
}
return nil
}
func (s *state) enumExists(ctx context.Context, ns *schema.Schema, e *schema.EnumType) (bool, error) {
query, args := `SELECT * FROM pg_type t JOIN pg_namespace n on t.typnamespace = n.oid WHERE t.typname = $1 AND t.typtype = 'e'`, []any{e.T}
if es := s.enumSchema(ns, e); es != "" {
query += " AND n.nspname = $2"
args = append(args, es)
}
rows, err := s.QueryContext(ctx, query, args...)
if err != nil {
return false, fmt.Errorf("check enum existence: %w", err)
}
defer rows.Close()
return rows.Next(), rows.Err()
}
// mayDropEnum drops dangling enum types form the schema.
func (s *state) mayDropEnum(alter *alterChange, ns *schema.Schema, e *schema.EnumType) error {
name := s.enumIdent(ns, e)
if _, ok := s.dropped[name]; ok {
return nil
}
schemas := []*schema.Schema{ns}
// In case there is a realm attached, traverse the entire tree.
if ns.Realm != nil && len(ns.Realm.Schemas) > 0 {
schemas = ns.Realm.Schemas
}
for i := range schemas {
for _, t := range schemas[i].Tables {
for _, c := range t.Columns {
e1, ok := hasEnumType(c)
// Although we search in siblings schemas, use the
// table's one for building the enum identifier.
if ok && s.enumIdent(ns, e1) == name {
return nil
}
}
}
}
s.dropped[name] = e
create, drop := s.createDropEnum(ns, e)
alter.after = append(alter.after, &migrate.Change{
Cmd: drop,
Reverse: create,
Comment: fmt.Sprintf("drop enum type %q", e.T),
})
return nil
}
func (s *state) addIndexes(t *schema.Table, indexes ...*schema.Index) {
for _, idx := range indexes {
b := s.Build("CREATE")
if idx.Unique {
b.P("UNIQUE")
}
b.P("INDEX")
if c := (Concurrently{}); sqlx.Has(idx.Attrs, &c) {
b.P("CONCURRENTLY")
}
if idx.Name != "" {
b.Ident(idx.Name)
}
b.P("ON").Table(t)
s.index(b, idx)
s.append(&migrate.Change{
Cmd: b.String(),
Comment: fmt.Sprintf("create index %q to table: %q", idx.Name, t.Name),
Reverse: func() string {
b := s.Build("DROP INDEX")
if c := (Concurrently{}); sqlx.Has(idx.Attrs, &c) {
b.P("CONCURRENTLY")
}
// Unlike MySQL, the DROP command is not attached to ALTER TABLE.
// Therefore, we print indexes with their qualified name, because
// the connection that executes the statements may not be attached
// to this schema.
if t.Schema != nil {
b.WriteString(s.schemaPrefix(t.Schema))
}
b.Ident(idx.Name)
return b.String()
}(),
})
}
}
func (s *state) column(b *sqlx.Builder, t *schema.Table, c *schema.Column) error {
f, err := s.formatType(t, c)
if err != nil {
return err
}
b.Ident(c.Name).P(f)
if !c.Type.Null {
b.P("NOT")
} else if t, ok := c.Type.Type.(*SerialType); ok {
return fmt.Errorf("NOT NULL constraint is required for %s column %q", t.T, c.Name)
}
b.P("NULL")
s.columnDefault(b, c)
for _, attr := range c.Attrs {
switch a := attr.(type) {
case *schema.Comment:
case *schema.Collation:
b.P("COLLATE").Ident(a.V)
case *Identity, *schema.GeneratedExpr:
// Handled below.
default:
return fmt.Errorf("unexpected column attribute: %T", attr)
}
}
switch hasI, hasX := sqlx.Has(c.Attrs, &Identity{}), sqlx.Has(c.Attrs, &schema.GeneratedExpr{}); {
case hasI && hasX:
return fmt.Errorf("both identity and generation expression specified for column %q", c.Name)
case hasI:
id, _ := identity(c.Attrs)
b.P("GENERATED", id.Generation, "AS IDENTITY")
if id.Sequence.Start != defaultSeqStart || id.Sequence.Increment != defaultSeqIncrement {
b.Wrap(func(b *sqlx.Builder) {
if id.Sequence.Start != defaultSeqStart {
b.P("START WITH", strconv.FormatInt(id.Sequence.Start, 10))
}
if id.Sequence.Increment != defaultSeqIncrement {
b.P("INCREMENT BY", strconv.FormatInt(id.Sequence.Increment, 10))
}
})
}
case hasX:
x := &schema.GeneratedExpr{}
sqlx.Has(c.Attrs, x)
b.P("GENERATED ALWAYS AS", sqlx.MayWrap(x.Expr), "STORED")
}
return nil
}
// columnDefault writes the default value of column to the builder.
func (s *state) columnDefault(b *sqlx.Builder, c *schema.Column) {
switch x := c.Default.(type) {
case *schema.Literal:
v := x.V
switch c.Type.Type.(type) {
case *schema.BoolType, *schema.DecimalType, *schema.IntegerType, *schema.FloatType:
default:
v = quote(v)
}
b.P("DEFAULT", v)
case *schema.RawExpr:
// Ignore identity functions added by the differ.
if _, ok := c.Type.Type.(*SerialType); !ok {
b.P("DEFAULT", x.X)
}
}
}
func (s *state) indexParts(b *sqlx.Builder, parts []*schema.IndexPart) {
b.Wrap(func(b *sqlx.Builder) {
b.MapComma(parts, func(i int, b *sqlx.Builder) {
switch part := parts[i]; {
case part.C != nil:
b.Ident(part.C.Name)
case part.X != nil:
b.WriteString(sqlx.MayWrap(part.X.(*schema.RawExpr).X))
}
s.partAttrs(b, parts[i])
})
})
}
func (s *state) partAttrs(b *sqlx.Builder, p *schema.IndexPart) {
if p.Desc {
b.P("DESC")
}
for _, attr := range p.Attrs {
switch attr := attr.(type) {
case *IndexColumnProperty:
switch {
// Defaults when DESC is specified.
case p.Desc && attr.NullsFirst:
case p.Desc && attr.NullsLast:
b.P("NULL LAST")
// Defaults when DESC is not specified.
case !p.Desc && attr.NullsLast:
case !p.Desc && attr.NullsFirst:
b.P("NULL FIRST")
}
case *schema.Collation:
b.P("COLLATE").Ident(attr.V)
default:
panic(fmt.Sprintf("unexpected index part attribute: %T", attr))
}
}
}
func (s *state) index(b *sqlx.Builder, idx *schema.Index) {
// Avoid appending the default method.
if t := (IndexType{}); sqlx.Has(idx.Attrs, &t) && strings.ToUpper(t.T) != IndexTypeBTree {
b.P("USING", t.T)
}
s.indexParts(b, idx.Parts)
if c := (IndexInclude{}); sqlx.Has(idx.Attrs, &c) {
b.P("INCLUDE")
b.Wrap(func(b *sqlx.Builder) {
b.MapComma(c.Columns, func(i int, b *sqlx.Builder) {
b.Ident(c.Columns[i].Name)
})
})
}
if p, ok := indexStorageParams(idx.Attrs); ok {
b.P("WITH")
b.Wrap(func(b *sqlx.Builder) {
var parts []string
if p.AutoSummarize {
parts = append(parts, "autosummarize = true")
}
if p.PagesPerRange != 0 && p.PagesPerRange != defaultPagePerRange {
parts = append(parts, fmt.Sprintf("pages_per_range = %d", p.PagesPerRange))
}
b.WriteString(strings.Join(parts, ", "))
})
}
if p := (IndexPredicate{}); sqlx.Has(idx.Attrs, &p) {
b.P("WHERE").P(p.P)
}
for _, attr := range idx.Attrs {
switch attr.(type) {
case *schema.Comment, *ConType, *IndexType, *IndexInclude, *Concurrently, *IndexPredicate, *IndexStorageParams:
default:
panic(fmt.Sprintf("unexpected index attribute: %T", attr))
}
}
}
func (s *state) fks(b *sqlx.Builder, fks ...*schema.ForeignKey) {
b.MapComma(fks, func(i int, b *sqlx.Builder) {
fk := fks[i]
if fk.Symbol != "" {
b.P("CONSTRAINT").Ident(fk.Symbol)
}
b.P("FOREIGN KEY")
b.Wrap(func(b *sqlx.Builder) {
b.MapComma(fk.Columns, func(i int, b *sqlx.Builder) {
b.Ident(fk.Columns[i].Name)
})
})
b.P("REFERENCES").Table(fk.RefTable)
b.Wrap(func(b *sqlx.Builder) {
b.MapComma(fk.RefColumns, func(i int, b *sqlx.Builder) {
b.Ident(fk.RefColumns[i].Name)
})
})
if fk.OnUpdate != "" {
b.P("ON UPDATE", string(fk.OnUpdate))
}
if fk.OnDelete != "" {
b.P("ON DELETE", string(fk.OnDelete))
}
})
}
func (s *state) append(c ...*migrate.Change) {
s.Changes = append(s.Changes, c...)
}
// Build instantiates a new builder and writes the given phrase to it.
func (s *state) Build(phrases ...string) *sqlx.Builder {
b := &sqlx.Builder{QuoteChar: '"', Schema: s.SchemaQualifier}
return b.P(phrases...)
}
// skipAutoChanges filters unnecessary changes that are automatically
// happened by the database when ALTER TABLE is executed.
func skipAutoChanges(changes []schema.Change) []schema.Change {
var (
dropC = make(map[string]bool)
planned = make([]schema.Change, 0, len(changes))
)
for _, c := range changes {
if c, ok := c.(*schema.DropColumn); ok {
dropC[c.C.Name] = true
}
}
search:
for _, c := range changes {
switch c := c.(type) {
// Indexes involving the column are automatically dropped
// with it. This is true for multi-columns indexes as well.
// See https://www.postgresql.org/docs/current/sql-altertable.html
case *schema.DropIndex:
for _, p := range c.I.Parts {
if p.C != nil && dropC[p.C.Name] {
continue search
}
}
// Simple case for skipping constraint dropping,
// if the child table columns were dropped.
case *schema.DropForeignKey:
for _, c := range c.F.Columns {
if dropC[c.Name] {
continue search
}
}
}
planned = append(planned, c)
}
return planned
}
// commentChange extracts the information for modifying a comment from the given change.
func commentChange(c schema.Change) (from, to string, err error) {
switch c := c.(type) {
case *schema.AddAttr:
toC, ok := c.A.(*schema.Comment)
if ok {
to = toC.Text
return
}
err = fmt.Errorf("unexpected AddAttr.(%T) for comment change", c.A)
case *schema.ModifyAttr:
fromC, ok1 := c.From.(*schema.Comment)
toC, ok2 := c.To.(*schema.Comment)
if ok1 && ok2 {
from, to = fromC.Text, toC.Text
return
}
err = fmt.Errorf("unsupported ModifyAttr(%T, %T) change", c.From, c.To)
default:
err = fmt.Errorf("unexpected change %T", c)
}
return
}
// checks writes the CHECK constraint to the builder.
func check(b *sqlx.Builder, c *schema.Check) {
if c.Name != "" {
b.P("CONSTRAINT").Ident(c.Name)
}
b.P("CHECK", sqlx.MayWrap(c.Expr))
if sqlx.Has(c.Attrs, &NoInherit{}) {
b.P("NO INHERIT")
}
}
// isUniqueConstraint reports if the index is a valid UNIQUE constraint.
func isUniqueConstraint(i *schema.Index) bool {
if c := (ConType{}); !sqlx.Has(i.Attrs, &c) || !c.IsUnique() || !i.Unique {
return false
}
// UNIQUE constraint cannot use functional indexes,
// and all its parts must have the default sort ordering.
for _, p := range i.Parts {
if p.X != nil || p.Desc {
return false
}
}
for _, a := range i.Attrs {
switch a := a.(type) {
// UNIQUE constraints must have BTREE type indexes.
case *IndexType:
if strings.ToUpper(a.T) != IndexTypeBTree {
return false
}
// Partial indexes are not allowed.
case *IndexPredicate:
return false
}
}
return true
}
func quote(s string) string {
if sqlx.IsQuoted(s, '\'') {
return s
}
return "'" + strings.ReplaceAll(s, "'", "''") + "'"
}
func (s *state) createDropEnum(sc *schema.Schema, e *schema.EnumType) (string, string) {
name := s.enumIdent(sc, e)
return s.Build("CREATE TYPE").
P(name, "AS ENUM").
Wrap(func(b *sqlx.Builder) {
b.MapComma(e.Values, func(i int, b *sqlx.Builder) {
b.WriteString(quote(e.Values[i]))
})
}).
String(),
s.Build("DROP TYPE").P(name).String()
}
func (s *state) enumIdent(ns *schema.Schema, e *schema.EnumType) string {
es := s.enumSchema(ns, e)
if es != "" {
return fmt.Sprintf("%q.%q", es, e.T)
}
return strconv.Quote(e.T)
}
func (s *state) enumSchema(ns *schema.Schema, e *schema.EnumType) (es string) {
switch {
// In case the plan uses a specific schema qualifier.
case s.SchemaQualifier != nil:
es = *s.SchemaQualifier
// Enum schema has higher precedence.
case e.Schema != nil:
es = e.Schema.Name
// Fallback to table schema if exists.
case ns != nil:
es = ns.Name
}
return
}
// schemaPrefix returns the schema prefix based on the planner config.
func (s *state) schemaPrefix(ns *schema.Schema) string {
switch {
case s.SchemaQualifier != nil:
// In case the qualifier is empty, ignore.
if *s.SchemaQualifier != "" {
return fmt.Sprintf("%q.", *s.SchemaQualifier)
}
case ns != nil && ns.Name != "":
return fmt.Sprintf("%q.", ns.Name)
}
return ""
}
// formatType formats the type but takes into account the qualifier.
func (s *state) formatType(t *schema.Table, c *schema.Column) (string, error) {
switch tt := c.Type.Type.(type) {
case *schema.EnumType:
return s.enumIdent(t.Schema, tt), nil
case *ArrayType:
if e, ok := tt.Type.(*schema.EnumType); ok {
return s.enumIdent(t.Schema, e) + "[]", nil
}
}
return FormatType(c.Type.Type)
}
func hasEnumType(c *schema.Column) (*schema.EnumType, bool) {
switch t := c.Type.Type.(type) {
case *schema.EnumType:
return t, true
case *ArrayType:
if e, ok := t.Type.(*schema.EnumType); ok {
return e, true
}
}
return nil, false
}
atlas-0.7.2/sql/postgres/migrate_test.go 0000664 0000000 0000000 00000115671 14314555116 0020327 0 ustar 00root root 0000000 0000000 // Copyright 2021-present The Atlas Authors. All rights reserved.
// This source code is licensed under the Apache 2.0 license found
// in the LICENSE file in the root directory of this source tree.
package postgres
import (
"context"
"strconv"
"testing"
"ariga.io/atlas/sql/internal/sqltest"
"ariga.io/atlas/sql/migrate"
"ariga.io/atlas/sql/schema"
"github.com/DATA-DOG/go-sqlmock"
"github.com/stretchr/testify/require"
)
func TestPlanChanges(t *testing.T) {
tests := []struct {
changes []schema.Change
options []migrate.PlanOption
mock func(mock)
wantPlan *migrate.Plan
wantErr bool
}{
{
changes: []schema.Change{
&schema.AddSchema{S: schema.New("test"), Extra: []schema.Clause{&schema.IfNotExists{}}},
&schema.DropSchema{S: schema.New("test"), Extra: []schema.Clause{&schema.IfExists{}}},
&schema.DropSchema{S: schema.New("test"), Extra: []schema.Clause{}},
},
wantPlan: &migrate.Plan{
Reversible: false,
Transactional: true,
Changes: []*migrate.Change{
{
Cmd: `CREATE SCHEMA IF NOT EXISTS "test"`,
Reverse: `DROP SCHEMA "test" CASCADE`,
},
{
Cmd: `DROP SCHEMA IF EXISTS "test" CASCADE`,
},
{
Cmd: `DROP SCHEMA "test" CASCADE`,
},
},
},
},
{
changes: []schema.Change{
func() schema.Change {
users := &schema.Table{
Name: "users",
Columns: []*schema.Column{
{Name: "id", Type: &schema.ColumnType{Type: &schema.IntegerType{T: "bigint"}}},
},
}
pets := &schema.Table{
Name: "pets",
Columns: []*schema.Column{
{Name: "id", Type: &schema.ColumnType{Type: &schema.IntegerType{T: "bigint"}}},
{Name: "user_id",
Type: &schema.ColumnType{
Type: &schema.IntegerType{T: "bigint"},
},
},
},
}
fk := &schema.ForeignKey{
Symbol: "pets_user_id_fkey",
Table: pets,
OnUpdate: schema.NoAction,
OnDelete: schema.Cascade,
RefTable: users,
Columns: []*schema.Column{pets.Columns[1]},
RefColumns: []*schema.Column{users.Columns[0]},
}
pets.ForeignKeys = []*schema.ForeignKey{fk}
return &schema.ModifyTable{
T: pets,
Changes: []schema.Change{
&schema.DropForeignKey{
F: fk,
},
},
}
}(),
},
wantPlan: &migrate.Plan{
Reversible: true,
Transactional: true,
Changes: []*migrate.Change{
{
Cmd: `ALTER TABLE "pets" DROP CONSTRAINT "pets_user_id_fkey"`,
Reverse: `ALTER TABLE "pets" ADD CONSTRAINT "pets_user_id_fkey" FOREIGN KEY ("user_id") REFERENCES "users" ("id") ON UPDATE NO ACTION ON DELETE CASCADE`,
},
},
},
},
{
changes: []schema.Change{
func() schema.Change {
users := &schema.Table{
Name: "users",
Columns: []*schema.Column{
{Name: "id", Type: &schema.ColumnType{Type: &schema.IntegerType{T: "bigint"}}},
{Name: "name", Type: &schema.ColumnType{Type: &schema.StringType{T: "varchar(255)"}}}},
}
return &schema.ModifyTable{
T: users,
Changes: []schema.Change{
&schema.DropIndex{
I: schema.NewIndex("name_index").
AddParts(schema.NewColumnPart(schema.NewColumn("name"))),
},
},
}
}(),
},
wantPlan: &migrate.Plan{
Reversible: true,
Transactional: true,
Changes: []*migrate.Change{
{
Cmd: `DROP INDEX "name_index"`,
Reverse: `CREATE INDEX "name_index" ON "users" ("name")`,
},
},
},
},
{
changes: []schema.Change{
func() schema.Change {
users := &schema.Table{
Name: "users",
Columns: []*schema.Column{
{Name: "id", Type: &schema.ColumnType{Type: &schema.IntegerType{T: "bigint"}}},
{Name: "nickname", Type: &schema.ColumnType{Type: &schema.StringType{T: "varchar(255)"}}}},
}
return &schema.ModifyTable{
T: users,
Changes: []schema.Change{
&schema.DropIndex{
I: schema.NewUniqueIndex("unique_nickname").
AddColumns(schema.NewColumn("nickname")).
AddAttrs(&ConType{T: "u"}),
},
},
}
}(),
},
wantPlan: &migrate.Plan{
Reversible: true,
Transactional: true,
Changes: []*migrate.Change{
{
Cmd: `ALTER TABLE "users" DROP CONSTRAINT "unique_nickname"`,
Reverse: `ALTER TABLE "users" ADD CONSTRAINT "unique_nickname" UNIQUE ("nickname")`,
},
},
},
},
{
changes: []schema.Change{
&schema.AddSchema{S: &schema.Schema{Name: "test"}},
},
wantPlan: &migrate.Plan{
Reversible: true,
Transactional: true,
Changes: []*migrate.Change{{Cmd: `CREATE SCHEMA "test"`, Reverse: `DROP SCHEMA "test" CASCADE`}}},
},
{
changes: []schema.Change{
&schema.DropSchema{S: &schema.Schema{Name: "atlas"}},
},
wantPlan: &migrate.Plan{
Transactional: true,
Changes: []*migrate.Change{{Cmd: `DROP SCHEMA "atlas" CASCADE`}},
},
},
{
changes: []schema.Change{
&schema.AddTable{
T: &schema.Table{
Name: "posts",
Columns: []*schema.Column{
{Name: "id", Type: &schema.ColumnType{Type: &schema.IntegerType{T: "integer"}}, Attrs: []schema.Attr{&Identity{}, &schema.Comment{}}},
{Name: "text", Type: &schema.ColumnType{Type: &schema.StringType{T: "text"}, Null: true}},
{Name: "directions", Type: &schema.ColumnType{Type: &ArrayType{T: "direction[]", Type: &schema.EnumType{T: "direction", Values: []string{"NORTH", "SOUTH"}, Schema: schema.New("public")}}}},
{Name: "states", Type: &schema.ColumnType{Type: &ArrayType{T: "state[]", Type: &schema.EnumType{T: "state", Values: []string{"ON", "OFF"}}}}},
},
Attrs: []schema.Attr{
&schema.Comment{},
&schema.Check{Name: "id_nonzero", Expr: `("id" > 0)`},
&schema.Check{Name: "text_len", Expr: `(length("text") > 0)`, Attrs: []schema.Attr{&NoInherit{}}},
&schema.Check{Name: "a_in_b", Expr: `(a) in (b)`},
&Partition{T: "HASH", Parts: []*PartitionPart{{C: schema.NewColumn("text")}}},
},
},
},
},
mock: func(m mock) {
m.ExpectQuery(sqltest.Escape("SELECT * FROM pg_type t JOIN pg_namespace n on t.typnamespace = n.oid WHERE t.typname = $1 AND t.typtype = 'e' AND n.nspname = $2")).
WithArgs("direction", "public").
WillReturnRows(sqlmock.NewRows([]string{"name"}))
m.ExpectQuery(sqltest.Escape("SELECT * FROM pg_type t JOIN pg_namespace n on t.typnamespace = n.oid WHERE t.typname = $1 AND t.typtype = 'e'")).
WithArgs("state").
WillReturnRows(sqlmock.NewRows([]string{"name"}).AddRow("state"))
},
wantPlan: &migrate.Plan{
Reversible: true,
Transactional: true,
Changes: []*migrate.Change{
{Cmd: `CREATE TYPE "public"."direction" AS ENUM ('NORTH', 'SOUTH')`, Reverse: `DROP TYPE "public"."direction"`},
{Cmd: `CREATE TABLE "posts" ("id" integer NOT NULL GENERATED BY DEFAULT AS IDENTITY, "text" text NULL, "directions" "public"."direction"[] NOT NULL, "states" "state"[] NOT NULL, CONSTRAINT "id_nonzero" CHECK ("id" > 0), CONSTRAINT "text_len" CHECK (length("text") > 0) NO INHERIT, CONSTRAINT "a_in_b" CHECK ((a) in (b))) PARTITION BY HASH ("text")`, Reverse: `DROP TABLE "posts"`},
},
},
},
{
changes: []schema.Change{
&schema.AddTable{
T: &schema.Table{
Name: "posts",
Columns: []*schema.Column{
{Name: "id", Type: &schema.ColumnType{Type: &schema.IntegerType{T: "integer"}}, Attrs: []schema.Attr{&Identity{Sequence: &Sequence{Start: 1024}}}},
},
},
},
},
wantPlan: &migrate.Plan{
Reversible: true,
Transactional: true,
Changes: []*migrate.Change{{Cmd: `CREATE TABLE "posts" ("id" integer NOT NULL GENERATED BY DEFAULT AS IDENTITY (START WITH 1024))`, Reverse: `DROP TABLE "posts"`}},
},
},
{
changes: []schema.Change{
&schema.AddTable{
T: &schema.Table{
Name: "posts",
Columns: []*schema.Column{
{Name: "id", Type: &schema.ColumnType{Type: &schema.IntegerType{T: "integer"}}},
{Name: "nid", Type: &schema.ColumnType{Type: &schema.IntegerType{T: "integer"}}, Attrs: []schema.Attr{&schema.GeneratedExpr{Expr: "id+1"}}},
},
},
},
},
wantPlan: &migrate.Plan{
Reversible: true,
Transactional: true,
Changes: []*migrate.Change{
{
Cmd: `CREATE TABLE "posts" ("id" integer NOT NULL, "nid" integer NOT NULL GENERATED ALWAYS AS (id+1) STORED)`,
Reverse: `DROP TABLE "posts"`,
},
},
},
},
{
changes: []schema.Change{
&schema.ModifyTable{
T: schema.NewTable("posts").
AddColumns(
schema.NewIntColumn("c1", "int").
SetGeneratedExpr(&schema.GeneratedExpr{Expr: "id+1"}),
),
Changes: []schema.Change{
&schema.ModifyColumn{
Change: schema.ChangeGenerated,
From: schema.NewIntColumn("c1", "int").
SetGeneratedExpr(&schema.GeneratedExpr{Expr: "id+1"}),
To: schema.NewIntColumn("c1", "int"),
},
},
},
},
wantPlan: &migrate.Plan{
Reversible: false,
Transactional: true,
Changes: []*migrate.Change{
{
Cmd: `ALTER TABLE "posts" ALTER COLUMN "c1" DROP EXPRESSION`,
},
},
},
},
{
changes: []schema.Change{
&schema.AddTable{
T: &schema.Table{
Name: "posts",
Columns: []*schema.Column{
{Name: "id", Type: &schema.ColumnType{Type: &schema.IntegerType{T: "integer"}}, Attrs: []schema.Attr{&Identity{Sequence: &Sequence{Increment: 2}}}},
},
},
},
},
wantPlan: &migrate.Plan{
Reversible: true,
Transactional: true,
Changes: []*migrate.Change{{Cmd: `CREATE TABLE "posts" ("id" integer NOT NULL GENERATED BY DEFAULT AS IDENTITY (INCREMENT BY 2))`, Reverse: `DROP TABLE "posts"`}},
},
},
{
changes: []schema.Change{
&schema.AddTable{
T: &schema.Table{
Name: "posts",
Columns: []*schema.Column{
{Name: "id", Type: &schema.ColumnType{Type: &schema.IntegerType{T: "integer"}}, Attrs: []schema.Attr{&Identity{Sequence: &Sequence{Start: 100, Increment: 2}}}},
},
},
},
},
wantPlan: &migrate.Plan{
Reversible: true,
Transactional: true,
Changes: []*migrate.Change{{Cmd: `CREATE TABLE "posts" ("id" integer NOT NULL GENERATED BY DEFAULT AS IDENTITY (START WITH 100 INCREMENT BY 2))`, Reverse: `DROP TABLE "posts"`}},
},
},
{
changes: []schema.Change{
&schema.DropTable{T: &schema.Table{Name: "posts"}},
},
wantPlan: &migrate.Plan{
Reversible: false,
Transactional: true,
Changes: []*migrate.Change{
{Cmd: `DROP TABLE "posts"`},
},
},
},
{
changes: []schema.Change{
func() schema.Change {
users := &schema.Table{
Name: "users",
Columns: []*schema.Column{
{Name: "id", Type: &schema.ColumnType{Type: &schema.IntegerType{T: "bigint"}}},
},
}
return &schema.ModifyTable{
T: users,
Changes: []schema.Change{
&schema.AddColumn{
C: &schema.Column{Name: "name", Type: &schema.ColumnType{Type: &schema.StringType{T: "varchar", Size: 255}}, Attrs: []schema.Attr{&schema.Comment{Text: "foo"}}, Default: &schema.Literal{V: "'logged_in'"}},
},
&schema.AddColumn{
C: &schema.Column{Name: "last", Type: &schema.ColumnType{Type: &schema.StringType{T: "varchar", Size: 255}}, Attrs: []schema.Attr{&schema.Comment{Text: "bar"}}, Default: &schema.RawExpr{X: "'logged_in'"}},
},
&schema.AddIndex{
I: &schema.Index{
Name: "id_key",
Parts: []*schema.IndexPart{
{C: users.Columns[0], Desc: true},
},
Attrs: []schema.Attr{
&schema.Comment{Text: "comment"},
&IndexPredicate{P: "success"},
},
},
},
&schema.AddIndex{
I: &schema.Index{
Name: "id_brin",
Parts: []*schema.IndexPart{
{C: users.Columns[0], Desc: true},
},
Attrs: []schema.Attr{
&IndexType{T: IndexTypeBRIN},
&IndexStorageParams{PagesPerRange: 2},
},
},
},
&schema.AddCheck{
C: &schema.Check{Name: "name_not_empty", Expr: `("name" <> '')`},
},
&schema.DropCheck{
C: &schema.Check{Name: "id_nonzero", Expr: `("id" <> 0)`},
},
&schema.ModifyCheck{
From: &schema.Check{Name: "id_iseven", Expr: `("id" % 2 = 0)`},
To: &schema.Check{Name: "id_iseven", Expr: `(("id") % 2 = 0)`},
},
&schema.AddIndex{
I: &schema.Index{
Name: "include_key",
Parts: []*schema.IndexPart{
{C: users.Columns[0]},
},
Attrs: []schema.Attr{
&IndexInclude{Columns: []*schema.Column{schema.NewColumn("a"), schema.NewColumn("b")}},
},
},
},
&schema.AddIndex{
I: &schema.Index{
Name: "concurrently",
Parts: []*schema.IndexPart{
{C: users.Columns[0]},
},
Attrs: []schema.Attr{
&Concurrently{},
},
},
},
},
}
}(),
},
wantPlan: &migrate.Plan{
Reversible: true,
Transactional: true,
Changes: []*migrate.Change{
{
Cmd: `ALTER TABLE "users" ADD COLUMN "name" character varying(255) NOT NULL DEFAULT 'logged_in', ADD COLUMN "last" character varying(255) NOT NULL DEFAULT 'logged_in', ADD CONSTRAINT "name_not_empty" CHECK ("name" <> ''), DROP CONSTRAINT "id_nonzero", DROP CONSTRAINT "id_iseven", ADD CONSTRAINT "id_iseven" CHECK (("id") % 2 = 0)`,
Reverse: `ALTER TABLE "users" DROP CONSTRAINT "id_iseven", ADD CONSTRAINT "id_iseven" CHECK ("id" % 2 = 0), ADD CONSTRAINT "id_nonzero" CHECK ("id" <> 0), DROP CONSTRAINT "name_not_empty", DROP COLUMN "last", DROP COLUMN "name"`,
},
{
Cmd: `CREATE INDEX "id_key" ON "users" ("id" DESC) WHERE success`,
Reverse: `DROP INDEX "id_key"`,
},
{
Cmd: `CREATE INDEX "id_brin" ON "users" USING BRIN ("id" DESC) WITH (pages_per_range = 2)`,
Reverse: `DROP INDEX "id_brin"`,
},
{
Cmd: `CREATE INDEX "include_key" ON "users" ("id") INCLUDE ("a", "b")`,
Reverse: `DROP INDEX "include_key"`,
},
{
Cmd: `CREATE INDEX CONCURRENTLY "concurrently" ON "users" ("id")`,
Reverse: `DROP INDEX CONCURRENTLY "concurrently"`,
},
{
Cmd: `COMMENT ON COLUMN "users" ."name" IS 'foo'`,
Reverse: `COMMENT ON COLUMN "users" ."name" IS ''`,
},
{
Cmd: `COMMENT ON COLUMN "users" ."last" IS 'bar'`,
Reverse: `COMMENT ON COLUMN "users" ."last" IS ''`,
},
{
Cmd: `COMMENT ON INDEX "id_key" IS 'comment'`,
Reverse: `COMMENT ON INDEX "id_key" IS ''`,
},
},
},
},
{
changes: []schema.Change{
func() schema.Change {
users := &schema.Table{
Name: "users",
Columns: []*schema.Column{
{Name: "id", Type: &schema.ColumnType{Type: &schema.IntegerType{T: "bigint"}}},
},
}
return &schema.ModifyTable{
T: users,
Changes: []schema.Change{
&schema.DropColumn{
C: &schema.Column{Name: "name", Type: &schema.ColumnType{Type: &schema.StringType{T: "varchar"}}},
},
&schema.ModifyColumn{
From: &schema.Column{Name: "id", Type: &schema.ColumnType{Type: &schema.IntegerType{T: "bigint"}}, Attrs: []schema.Attr{&Identity{}, &schema.Comment{Text: "comment"}}},
To: &schema.Column{Name: "id", Type: &schema.ColumnType{Type: &schema.IntegerType{T: "bigint"}}, Attrs: []schema.Attr{&Identity{Sequence: &Sequence{Start: 1024}}}},
Change: schema.ChangeAttr | schema.ChangeComment,
},
},
}
}(),
},
wantPlan: &migrate.Plan{
Reversible: true,
Transactional: true,
Changes: []*migrate.Change{
{
Cmd: `ALTER TABLE "users" DROP COLUMN "name", ALTER COLUMN "id" SET GENERATED BY DEFAULT SET START WITH 1024 SET INCREMENT BY 1 RESTART`,
Reverse: `ALTER TABLE "users" ALTER COLUMN "id" SET GENERATED BY DEFAULT SET START WITH 1 SET INCREMENT BY 1 RESTART, ADD COLUMN "name" character varying NOT NULL`,
},
{
Cmd: `COMMENT ON COLUMN "users" ."id" IS ''`,
Reverse: `COMMENT ON COLUMN "users" ."id" IS 'comment'`,
},
},
},
},
{
changes: []schema.Change{
func() schema.Change {
users := &schema.Table{
Name: "users",
Columns: []*schema.Column{
{Name: "id", Type: &schema.ColumnType{Type: &schema.IntegerType{T: "bigint"}}},
},
}
return &schema.ModifyTable{
T: users,
Changes: []schema.Change{
&schema.DropColumn{
C: &schema.Column{Name: "name", Type: &schema.ColumnType{Type: &schema.StringType{T: "varchar"}}},
},
&schema.ModifyColumn{
From: &schema.Column{Name: "id", Type: &schema.ColumnType{Type: &schema.IntegerType{T: "bigint"}}, Attrs: []schema.Attr{&Identity{Sequence: &Sequence{Start: 0, Last: 1025}}}},
To: &schema.Column{Name: "id", Type: &schema.ColumnType{Type: &schema.IntegerType{T: "bigint"}}, Attrs: []schema.Attr{&Identity{Sequence: &Sequence{Start: 1024}}}},
Change: schema.ChangeAttr,
},
},
}
}(),
},
wantPlan: &migrate.Plan{
Reversible: true,
Transactional: true,
Changes: []*migrate.Change{
{
Cmd: `ALTER TABLE "users" DROP COLUMN "name", ALTER COLUMN "id" SET GENERATED BY DEFAULT SET START WITH 1024 SET INCREMENT BY 1`,
Reverse: `ALTER TABLE "users" ALTER COLUMN "id" SET GENERATED BY DEFAULT SET START WITH 1 SET INCREMENT BY 1, ADD COLUMN "name" character varying NOT NULL`,
},
},
},
},
{
changes: []schema.Change{
&schema.ModifyTable{
T: &schema.Table{Name: "users", Schema: &schema.Schema{Name: "public"}},
Changes: []schema.Change{
&schema.AddAttr{
A: &schema.Comment{Text: "foo"},
},
},
},
},
wantPlan: &migrate.Plan{
Reversible: true,
Transactional: true,
Changes: []*migrate.Change{
{Cmd: `COMMENT ON TABLE "public"."users" IS 'foo'`, Reverse: `COMMENT ON TABLE "public"."users" IS ''`},
},
},
},
{
changes: []schema.Change{
&schema.ModifyTable{
T: &schema.Table{Name: "users", Schema: &schema.Schema{Name: "public"}},
Changes: []schema.Change{
&schema.ModifyAttr{
To: &schema.Comment{Text: "foo"},
From: &schema.Comment{Text: "bar"},
},
},
},
},
wantPlan: &migrate.Plan{
Reversible: true,
Transactional: true,
Changes: []*migrate.Change{
{Cmd: `COMMENT ON TABLE "public"."users" IS 'foo'`, Reverse: `COMMENT ON TABLE "public"."users" IS 'bar'`},
},
},
},
{
changes: []schema.Change{
func() schema.Change {
users := schema.NewTable("users").
SetSchema(schema.New("public")).
AddColumns(
schema.NewEnumColumn("state", schema.EnumName("state"), schema.EnumValues("on", "off")),
schema.NewEnumColumn("status", schema.EnumName("status"), schema.EnumValues("a", "b"), schema.EnumSchema(schema.New("test"))),
)
return &schema.ModifyTable{
T: users,
Changes: []schema.Change{
&schema.ModifyColumn{
From: &schema.Column{Name: "state", Type: &schema.ColumnType{Type: &schema.StringType{T: "text"}}},
To: users.Columns[0],
Change: schema.ChangeType,
},
&schema.ModifyColumn{
From: &schema.Column{Name: "status", Type: &schema.ColumnType{Type: &schema.StringType{T: "text"}}},
To: users.Columns[1],
Change: schema.ChangeType,
},
&schema.DropColumn{
C: schema.NewEnumColumn("dc1", schema.EnumName("de"), schema.EnumValues("on")),
},
&schema.DropColumn{
C: schema.NewEnumColumn("dc2", schema.EnumName("de"), schema.EnumValues("on")),
},
},
}
}(),
},
mock: func(m mock) {
m.ExpectQuery(sqltest.Escape("SELECT * FROM pg_type t JOIN pg_namespace n on t.typnamespace = n.oid WHERE t.typname = $1 AND t.typtype = 'e' AND n.nspname = $2 ")).
WithArgs("state", "public").
WillReturnRows(sqlmock.NewRows([]string{"name"}))
m.ExpectQuery(sqltest.Escape("SELECT * FROM pg_type t JOIN pg_namespace n on t.typnamespace = n.oid WHERE t.typname = $1 AND t.typtype = 'e' AND n.nspname = $2 ")).
WithArgs("status", "test").
WillReturnRows(sqlmock.NewRows([]string{"name"}))
},
wantPlan: &migrate.Plan{
Reversible: true,
Transactional: true,
Changes: []*migrate.Change{
{Cmd: `CREATE TYPE "public"."state" AS ENUM ('on', 'off')`, Reverse: `DROP TYPE "public"."state"`},
{Cmd: `CREATE TYPE "test"."status" AS ENUM ('a', 'b')`, Reverse: `DROP TYPE "test"."status"`},
{Cmd: `ALTER TABLE "public"."users" ALTER COLUMN "state" TYPE "public"."state", ALTER COLUMN "status" TYPE "test"."status", DROP COLUMN "dc1", DROP COLUMN "dc2"`, Reverse: `ALTER TABLE "public"."users" ADD COLUMN "dc2" "public"."de" NOT NULL, ADD COLUMN "dc1" "public"."de" NOT NULL, ALTER COLUMN "status" TYPE text, ALTER COLUMN "state" TYPE text`},
{Cmd: `DROP TYPE "public"."de"`, Reverse: `CREATE TYPE "public"."de" AS ENUM ('on')`},
},
},
},
{
changes: []schema.Change{
func() schema.Change {
users := schema.NewTable("users").
SetSchema(schema.New("public")).
AddColumns(
schema.NewEnumColumn("state", schema.EnumName("state"), schema.EnumValues("on", "off")),
)
return &schema.ModifyTable{
T: users,
Changes: []schema.Change{
&schema.ModifyColumn{
From: users.Columns[0],
To: &schema.Column{Name: "state", Type: &schema.ColumnType{Type: &schema.EnumType{T: "state", Values: []string{"on", "off", "unknown"}}}},
Change: schema.ChangeType,
},
},
}
}(),
},
wantPlan: &migrate.Plan{
Reversible: false,
Transactional: true,
Changes: []*migrate.Change{
{Cmd: `ALTER TYPE "public"."state" ADD VALUE 'unknown'`},
},
},
},
// Modify column type and drop comment.
{
changes: []schema.Change{
func() schema.Change {
users := schema.NewTable("users").
SetSchema(schema.New("public")).
AddColumns(
schema.NewEnumColumn("state", schema.EnumName("state"), schema.EnumValues("on", "off")),
)
return &schema.ModifyTable{
T: users,
Changes: []schema.Change{
&schema.ModifyColumn{
From: &schema.Column{Name: "state", Type: &schema.ColumnType{Type: &schema.EnumType{T: "state", Values: []string{"on", "off"}}}, Attrs: []schema.Attr{&schema.Comment{Text: "foo"}}},
To: &schema.Column{Name: "state", Type: &schema.ColumnType{Type: &schema.EnumType{T: "state", Values: []string{"on", "off", "unknown"}}}},
Change: schema.ChangeType | schema.ChangeComment,
},
},
}
}(),
},
wantPlan: &migrate.Plan{
Reversible: false,
Transactional: true,
Changes: []*migrate.Change{
{Cmd: `ALTER TYPE "public"."state" ADD VALUE 'unknown'`},
{Cmd: `COMMENT ON COLUMN "public"."users" ."state" IS ''`, Reverse: `COMMENT ON COLUMN "public"."users" ."state" IS 'foo'`},
},
},
},
// Modify column type and add comment.
{
changes: []schema.Change{
func() schema.Change {
users := &schema.Table{
Name: "users",
Columns: []*schema.Column{
{Name: "state", Type: &schema.ColumnType{Type: &schema.EnumType{T: "state", Values: []string{"on", "off"}}}},
},
}
return &schema.ModifyTable{
T: users,
Changes: []schema.Change{
&schema.ModifyColumn{
From: &schema.Column{Name: "state", Type: &schema.ColumnType{Type: &schema.EnumType{T: "state", Values: []string{"on", "off"}}}},
To: &schema.Column{Name: "state", Type: &schema.ColumnType{Type: &schema.EnumType{T: "state", Values: []string{"on", "off", "unknown"}}}, Attrs: []schema.Attr{&schema.Comment{Text: "foo"}}},
Change: schema.ChangeType | schema.ChangeComment,
},
},
}
}(),
},
wantPlan: &migrate.Plan{
Reversible: false,
Transactional: true,
Changes: []*migrate.Change{
{Cmd: `ALTER TYPE "state" ADD VALUE 'unknown'`},
{Cmd: `COMMENT ON COLUMN "users" ."state" IS 'foo'`, Reverse: `COMMENT ON COLUMN "users" ."state" IS ''`},
},
},
},
// Modify column comment.
{
changes: []schema.Change{
func() schema.Change {
users := &schema.Table{
Name: "users",
Columns: []*schema.Column{
{Name: "state", Type: &schema.ColumnType{Type: &schema.StringType{T: "text"}}},
},
}
return &schema.ModifyTable{
T: users,
Changes: []schema.Change{
&schema.ModifyColumn{
From: &schema.Column{Name: "state", Type: &schema.ColumnType{Type: &schema.StringType{T: "text"}}, Attrs: []schema.Attr{&schema.Comment{Text: "bar"}}},
To: &schema.Column{Name: "state", Type: &schema.ColumnType{Type: &schema.StringType{T: "text"}}, Attrs: []schema.Attr{&schema.Comment{Text: "foo"}}},
Change: schema.ChangeComment,
},
},
}
}(),
},
wantPlan: &migrate.Plan{
Reversible: true,
Transactional: true,
Changes: []*migrate.Change{
{Cmd: `COMMENT ON COLUMN "users" ."state" IS 'foo'`, Reverse: `COMMENT ON COLUMN "users" ."state" IS 'bar'`},
},
},
},
// Modify index comment.
{
changes: []schema.Change{
func() schema.Change {
users := &schema.Table{
Name: "users",
Columns: []*schema.Column{
{Name: "id", Type: &schema.ColumnType{Type: &schema.IntegerType{T: "bigint"}}},
},
}
return &schema.ModifyTable{
T: users,
Changes: []schema.Change{
&schema.ModifyIndex{
From: schema.NewIndex("id_key").
AddColumns(users.Columns[0]).
SetComment("foo"),
To: schema.NewIndex("id_key").
AddColumns(users.Columns[0]).
SetComment("bar"),
Change: schema.ChangeComment,
},
},
}
}(),
},
wantPlan: &migrate.Plan{
Reversible: true,
Transactional: true,
Changes: []*migrate.Change{
{Cmd: `COMMENT ON INDEX "id_key" IS 'bar'`, Reverse: `COMMENT ON INDEX "id_key" IS 'foo'`},
},
},
},
// Modify default values.
{
changes: []schema.Change{
func() schema.Change {
users := &schema.Table{
Name: "users",
Columns: []*schema.Column{
{Name: "id", Type: &schema.ColumnType{Type: &schema.IntegerType{T: "bigint"}}},
{Name: "one", Default: &schema.Literal{V: "'one'"}, Type: &schema.ColumnType{Type: &schema.IntegerType{T: "bigint"}}},
{Name: "two", Default: &schema.Literal{V: "'two'"}, Type: &schema.ColumnType{Type: &schema.IntegerType{T: "bigint"}}},
},
}
return &schema.ModifyTable{
T: users,
Changes: []schema.Change{
&schema.ModifyColumn{
From: &schema.Column{Name: "one", Default: &schema.Literal{V: "'one'"}, Type: &schema.ColumnType{Type: &schema.IntegerType{T: "bigint"}}},
To: &schema.Column{Name: "one", Type: &schema.ColumnType{Type: &schema.IntegerType{T: "bigint"}}},
Change: schema.ChangeDefault,
},
&schema.ModifyColumn{
From: &schema.Column{Name: "two", Default: &schema.Literal{V: "'two'"}, Type: &schema.ColumnType{Type: &schema.IntegerType{T: "bigint"}}},
To: &schema.Column{Name: "two", Type: &schema.ColumnType{Type: &schema.IntegerType{T: "bigint"}}},
Change: schema.ChangeDefault,
},
&schema.ModifyColumn{
From: &schema.Column{Name: "id", Type: &schema.ColumnType{Type: &schema.IntegerType{T: "bigint"}}, Attrs: []schema.Attr{&Identity{}}},
To: &schema.Column{Name: "id", Type: &schema.ColumnType{Type: &schema.IntegerType{T: "bigint"}}, Attrs: []schema.Attr{&Identity{Sequence: &Sequence{Start: 1024}}}},
Change: schema.ChangeAttr,
},
},
}
}(),
},
wantPlan: &migrate.Plan{
Reversible: true,
Transactional: true,
Changes: []*migrate.Change{
{
Cmd: `ALTER TABLE "users" ALTER COLUMN "one" DROP DEFAULT, ALTER COLUMN "two" DROP DEFAULT, ALTER COLUMN "id" SET GENERATED BY DEFAULT SET START WITH 1024 SET INCREMENT BY 1 RESTART`,
Reverse: `ALTER TABLE "users" ALTER COLUMN "id" SET GENERATED BY DEFAULT SET START WITH 1 SET INCREMENT BY 1 RESTART, ALTER COLUMN "two" SET DEFAULT 'two', ALTER COLUMN "one" SET DEFAULT 'one'`,
},
},
},
},
{
changes: []schema.Change{
&schema.RenameTable{
From: schema.NewTable("t1").SetSchema(schema.New("s1")),
To: schema.NewTable("t2").SetSchema(schema.New("s2")),
},
},
wantPlan: &migrate.Plan{
Reversible: true,
Transactional: true,
Changes: []*migrate.Change{
{
Cmd: `ALTER TABLE "s1"."t1" RENAME TO "s2"."t2"`,
Reverse: `ALTER TABLE "s2"."t2" RENAME TO "s1"."t1"`,
},
},
},
},
{
changes: []schema.Change{
&schema.ModifyTable{
T: schema.NewTable("t1").SetSchema(schema.New("s1")),
Changes: []schema.Change{
&schema.RenameColumn{
From: schema.NewColumn("a"),
To: schema.NewColumn("b"),
},
},
},
},
wantPlan: &migrate.Plan{
Reversible: true,
Transactional: true,
Changes: []*migrate.Change{
{
Cmd: `ALTER TABLE "s1"."t1" RENAME COLUMN "a" TO "b"`,
Reverse: `ALTER TABLE "s1"."t1" RENAME COLUMN "b" TO "a"`,
},
},
},
},
{
changes: []schema.Change{
&schema.ModifyTable{
T: schema.NewTable("t1").SetSchema(schema.New("s1")),
Changes: []schema.Change{
&schema.RenameColumn{
From: schema.NewColumn("a"),
To: schema.NewColumn("b"),
},
&schema.AddColumn{
C: schema.NewIntColumn("c", "int"),
},
},
},
},
wantPlan: &migrate.Plan{
Reversible: true,
Transactional: true,
Changes: []*migrate.Change{
{
Cmd: `ALTER TABLE "s1"."t1" ADD COLUMN "c" integer NOT NULL`,
Reverse: `ALTER TABLE "s1"."t1" DROP COLUMN "c"`,
},
{
Cmd: `ALTER TABLE "s1"."t1" RENAME COLUMN "a" TO "b"`,
Reverse: `ALTER TABLE "s1"."t1" RENAME COLUMN "b" TO "a"`,
},
},
},
},
{
changes: []schema.Change{
&schema.ModifyTable{
T: schema.NewTable("t1").SetSchema(schema.New("s1")),
Changes: []schema.Change{
&schema.RenameIndex{
From: schema.NewIndex("a"),
To: schema.NewIndex("b"),
},
},
},
},
wantPlan: &migrate.Plan{
Reversible: true,
Transactional: true,
Changes: []*migrate.Change{
{
Cmd: `ALTER INDEX "a" RENAME TO "b"`,
Reverse: `ALTER INDEX "b" RENAME TO "a"`,
},
},
},
},
// Invalid serial type.
{
changes: []schema.Change{
&schema.AddTable{
T: &schema.Table{
Name: "posts",
Columns: []*schema.Column{
{Name: "id", Type: &schema.ColumnType{Type: &SerialType{T: "serial"}, Null: true}},
},
},
},
},
wantErr: true,
},
// Drop serial sequence.
{
changes: []schema.Change{
&schema.ModifyTable{
T: schema.NewTable("posts").
SetSchema(schema.New("public")).
AddColumns(
schema.NewIntColumn("c1", "integer"),
schema.NewIntColumn("c2", "integer"),
),
Changes: schema.Changes{
&schema.ModifyColumn{
From: schema.NewColumn("c1").SetType(&SerialType{T: "smallserial"}),
To: schema.NewIntColumn("c1", "integer"),
Change: schema.ChangeType,
},
&schema.ModifyColumn{
From: schema.NewColumn("c2").SetType(&SerialType{T: "serial", SequenceName: "previous_name"}),
To: schema.NewIntColumn("c2", "integer"),
Change: schema.ChangeType,
},
},
},
},
wantPlan: &migrate.Plan{
Reversible: true,
Transactional: true,
Changes: []*migrate.Change{
{
Cmd: `ALTER TABLE "public"."posts" ALTER COLUMN "c1" DROP DEFAULT, ALTER COLUMN "c1" TYPE integer, ALTER COLUMN "c2" DROP DEFAULT`,
Reverse: `ALTER TABLE "public"."posts" ALTER COLUMN "c2" SET DEFAULT nextval('"public"."previous_name"'), ALTER COLUMN "c1" SET DEFAULT nextval('"public"."posts_c1_seq"'), ALTER COLUMN "c1" TYPE smallint`,
},
{
Cmd: `DROP SEQUENCE IF EXISTS "public"."posts_c1_seq"`,
Reverse: `CREATE SEQUENCE IF NOT EXISTS "public"."posts_c1_seq" OWNED BY "public"."posts"."c1"`,
},
{
Cmd: `DROP SEQUENCE IF EXISTS "public"."previous_name"`,
Reverse: `CREATE SEQUENCE IF NOT EXISTS "public"."previous_name" OWNED BY "public"."posts"."c2"`,
},
},
},
},
// Add serial sequence.
{
changes: []schema.Change{
&schema.ModifyTable{
T: schema.NewTable("posts").
SetSchema(schema.New("public")).
AddColumns(
schema.NewColumn("c1").SetType(&SerialType{T: "serial"}),
schema.NewColumn("c2").SetType(&SerialType{T: "bigserial"}),
),
Changes: schema.Changes{
&schema.ModifyColumn{
From: schema.NewIntColumn("c1", "integer"),
To: schema.NewColumn("c1").SetType(&SerialType{T: "serial"}),
Change: schema.ChangeType,
},
&schema.ModifyColumn{
From: schema.NewIntColumn("c2", "integer"),
To: schema.NewColumn("c2").SetType(&SerialType{T: "bigserial"}),
Change: schema.ChangeType,
},
},
},
},
wantPlan: &migrate.Plan{
Reversible: true,
Transactional: true,
Changes: []*migrate.Change{
{
Cmd: `CREATE SEQUENCE IF NOT EXISTS "public"."posts_c1_seq" OWNED BY "public"."posts"."c1"`,
Reverse: `DROP SEQUENCE IF EXISTS "public"."posts_c1_seq"`,
},
{
Cmd: `CREATE SEQUENCE IF NOT EXISTS "public"."posts_c2_seq" OWNED BY "public"."posts"."c2"`,
Reverse: `DROP SEQUENCE IF EXISTS "public"."posts_c2_seq"`,
},
{
Cmd: `ALTER TABLE "public"."posts" ALTER COLUMN "c1" SET DEFAULT nextval('"public"."posts_c1_seq"'), ALTER COLUMN "c2" SET DEFAULT nextval('"public"."posts_c2_seq"'), ALTER COLUMN "c2" TYPE bigint`,
Reverse: `ALTER TABLE "public"."posts" ALTER COLUMN "c2" DROP DEFAULT, ALTER COLUMN "c2" TYPE integer, ALTER COLUMN "c1" DROP DEFAULT`,
},
},
},
},
// Change underlying sequence type.
{
changes: []schema.Change{
&schema.ModifyTable{
T: schema.NewTable("posts").
SetSchema(schema.New("public")).
AddColumns(
schema.NewColumn("c1").SetType(&SerialType{T: "serial"}),
schema.NewColumn("c2").SetType(&SerialType{T: "bigserial"}),
),
Changes: schema.Changes{
&schema.ModifyColumn{
From: schema.NewColumn("c1").SetType(&SerialType{T: "smallserial"}),
To: schema.NewColumn("c1").SetType(&SerialType{T: "serial"}),
Change: schema.ChangeType,
},
&schema.ModifyColumn{
From: schema.NewColumn("c2").SetType(&SerialType{T: "serial"}),
To: schema.NewColumn("c2").SetType(&SerialType{T: "bigserial"}),
Change: schema.ChangeType,
},
},
},
},
wantPlan: &migrate.Plan{
Reversible: true,
Transactional: true,
Changes: []*migrate.Change{
{
Cmd: `ALTER TABLE "public"."posts" ALTER COLUMN "c1" TYPE integer, ALTER COLUMN "c2" TYPE bigint`,
Reverse: `ALTER TABLE "public"."posts" ALTER COLUMN "c2" TYPE integer, ALTER COLUMN "c1" TYPE smallint`,
},
},
},
},
// Empty qualifier.
{
changes: []schema.Change{
&schema.AddTable{
T: schema.NewTable("posts").
SetSchema(schema.New("test1")).
AddColumns(
schema.NewEnumColumn("c1", schema.EnumName("enum"), schema.EnumValues("a"), schema.EnumSchema(schema.New("test2"))),
),
},
},
options: []migrate.PlanOption{
func(o *migrate.PlanOptions) { o.SchemaQualifier = new(string) },
},
mock: func(m mock) {
m.ExpectQuery(sqltest.Escape("SELECT * FROM pg_type t JOIN pg_namespace n on t.typnamespace = n.oid WHERE t.typname = $1 AND t.typtype = 'e'")).
WithArgs("enum").
WillReturnRows(sqlmock.NewRows([]string{"name"}))
},
wantPlan: &migrate.Plan{
Reversible: true,
Transactional: true,
Changes: []*migrate.Change{
{
Cmd: `CREATE TYPE "enum" AS ENUM ('a')`,
Reverse: `DROP TYPE "enum"`,
},
{
Cmd: `CREATE TABLE "posts" ("c1" "enum" NOT NULL)`,
Reverse: `DROP TABLE "posts"`,
},
},
},
},
// Empty sequence qualifier.
{
changes: []schema.Change{
&schema.ModifyTable{
T: schema.NewTable("posts").
SetSchema(schema.New("public")).
AddColumns(
schema.NewColumn("c1").SetType(&SerialType{T: "serial"}),
),
Changes: schema.Changes{
&schema.ModifyColumn{
From: schema.NewIntColumn("c1", "integer"),
To: schema.NewColumn("c1").SetType(&SerialType{T: "serial"}),
Change: schema.ChangeType,
},
},
},
},
options: []migrate.PlanOption{
func(o *migrate.PlanOptions) { o.SchemaQualifier = new(string) },
},
wantPlan: &migrate.Plan{
Reversible: true,
Transactional: true,
Changes: []*migrate.Change{
{
Cmd: `CREATE SEQUENCE IF NOT EXISTS "posts_c1_seq" OWNED BY "posts"."c1"`,
Reverse: `DROP SEQUENCE IF EXISTS "posts_c1_seq"`,
},
{
Cmd: `ALTER TABLE "posts" ALTER COLUMN "c1" SET DEFAULT nextval('"posts_c1_seq"')`,
Reverse: `ALTER TABLE "posts" ALTER COLUMN "c1" DROP DEFAULT`,
},
},
},
},
// Empty index qualifier.
{
changes: []schema.Change{
&schema.ModifyTable{
T: schema.NewTable("posts").
SetSchema(schema.New("public")).
AddColumns(
schema.NewIntColumn("c", "int"),
),
Changes: schema.Changes{
&schema.AddIndex{
I: schema.NewIndex("i").AddColumns(schema.NewIntColumn("c", "int")),
},
},
},
},
options: []migrate.PlanOption{
func(o *migrate.PlanOptions) { o.SchemaQualifier = new(string) },
},
wantPlan: &migrate.Plan{
Reversible: true,
Transactional: true,
Changes: []*migrate.Change{
{
Cmd: `CREATE INDEX "i" ON "posts" ("c")`,
Reverse: `DROP INDEX "i"`,
},
},
},
},
// Empty qualifier in multi-schema mode should fail.
{
changes: []schema.Change{
&schema.AddTable{T: schema.NewTable("t1").SetSchema(schema.New("s1")).AddColumns(schema.NewIntColumn("a", "int"))},
&schema.AddTable{T: schema.NewTable("t2").SetSchema(schema.New("s2")).AddColumns(schema.NewIntColumn("a", "int"))},
},
options: []migrate.PlanOption{
func(o *migrate.PlanOptions) { o.SchemaQualifier = new(string) },
},
wantErr: true,
},
}
for i, tt := range tests {
t.Run(strconv.Itoa(i), func(t *testing.T) {
db, mk, err := sqlmock.New()
require.NoError(t, err)
m := mock{mk}
m.version("130000")
if tt.mock != nil {
tt.mock(m)
}
drv, err := Open(db)
require.NoError(t, err)
plan, err := drv.PlanChanges(context.Background(), "wantPlan", tt.changes, tt.options...)
if tt.wantErr {
require.Error(t, err, "expect plan to fail")
return
}
require.NoError(t, err)
require.Equal(t, tt.wantPlan.Reversible, plan.Reversible)
require.Equal(t, tt.wantPlan.Transactional, plan.Transactional)
for i, c := range plan.Changes {
require.Equal(t, tt.wantPlan.Changes[i].Cmd, c.Cmd)
require.Equal(t, tt.wantPlan.Changes[i].Reverse, c.Reverse)
}
})
}
}
atlas-0.7.2/sql/postgres/postgrescheck/ 0000775 0000000 0000000 00000000000 14314555116 0020142 5 ustar 00root root 0000000 0000000 atlas-0.7.2/sql/postgres/postgrescheck/postgrescheck.go 0000664 0000000 0000000 00000002157 14314555116 0023342 0 ustar 00root root 0000000 0000000 // Copyright 2021-present The Atlas Authors. All rights reserved.
// This source code is licensed under the Apache 2.0 license found
// in the LICENSE file in the root directory of this source tree.
package postgrescheck
import (
"fmt"
"ariga.io/atlas/schemahcl"
"ariga.io/atlas/sql/postgres"
"ariga.io/atlas/sql/sqlcheck"
"ariga.io/atlas/sql/sqlcheck/datadepend"
"ariga.io/atlas/sql/sqlcheck/destructive"
)
func addNotNull(p *datadepend.ColumnPass) (diags []sqlcheck.Diagnostic, err error) {
tt, err := postgres.FormatType(p.Column.Type.Type)
if err != nil {
return nil, err
}
return []sqlcheck.Diagnostic{
{
Pos: p.Change.Stmt.Pos,
Text: fmt.Sprintf(
"Adding a non-nullable %q column %q will fail in case table %q is not empty",
tt, p.Column.Name, p.Table.Name,
),
},
}, nil
}
func init() {
sqlcheck.Register(postgres.DriverName, func(r *schemahcl.Resource) ([]sqlcheck.Analyzer, error) {
ds, err := destructive.New(r)
if err != nil {
return nil, err
}
dd, err := datadepend.New(r, datadepend.Handler{
AddNotNull: addNotNull,
})
return []sqlcheck.Analyzer{ds, dd}, nil
})
}
atlas-0.7.2/sql/postgres/postgrescheck/postgrescheck_test.go 0000664 0000000 0000000 00000003226 14314555116 0024377 0 ustar 00root root 0000000 0000000 // Copyright 2021-present The Atlas Authors. All rights reserved.
// This source code is licensed under the Apache 2.0 license found
// in the LICENSE file in the root directory of this source tree.
package postgrescheck_test
import (
"context"
"testing"
"ariga.io/atlas/sql/migrate"
"ariga.io/atlas/sql/postgres"
_ "ariga.io/atlas/sql/postgres/postgrescheck"
"ariga.io/atlas/sql/schema"
"ariga.io/atlas/sql/sqlcheck"
"github.com/stretchr/testify/require"
)
func TestDataDepend_MightFail(t *testing.T) {
var (
report *sqlcheck.Report
pass = &sqlcheck.Pass{
File: &sqlcheck.File{
File: testFile{name: "1.sql"},
Changes: []*sqlcheck.Change{
{
Stmt: &migrate.Stmt{
Text: "ALTER TABLE users",
},
Changes: schema.Changes{
&schema.ModifyTable{
T: schema.NewTable("users").
SetSchema(schema.New("test")).
AddColumns(
schema.NewIntColumn("a", postgres.TypeInt),
schema.NewIntColumn("b", postgres.TypeInt),
),
Changes: []schema.Change{
&schema.AddColumn{C: schema.NewTimeColumn("b", postgres.TypeInt)},
},
},
},
},
},
},
Reporter: sqlcheck.ReportWriterFunc(func(r sqlcheck.Report) {
report = &r
}),
}
)
azs, err := sqlcheck.AnalyzerFor(postgres.DriverName, nil)
require.NoError(t, err)
require.NoError(t, sqlcheck.Analyzers(azs).Analyze(context.Background(), pass))
require.Equal(t, report.Diagnostics[0].Text, `Adding a non-nullable "int" column "b" will fail in case table "users" is not empty`)
}
type testFile struct {
name string
migrate.File
}
func (t testFile) Name() string {
return t.name
}
atlas-0.7.2/sql/postgres/sqlspec.go 0000664 0000000 0000000 00000054621 14314555116 0017307 0 ustar 00root root 0000000 0000000 // Copyright 2021-present The Atlas Authors. All rights reserved.
// This source code is licensed under the Apache 2.0 license found
// in the LICENSE file in the root directory of this source tree.
package postgres
import (
"fmt"
"reflect"
"strconv"
"strings"
"ariga.io/atlas/schemahcl"
"ariga.io/atlas/sql/internal/specutil"
"ariga.io/atlas/sql/internal/sqlx"
"ariga.io/atlas/sql/schema"
"ariga.io/atlas/sql/sqlspec"
"github.com/hashicorp/hcl/v2/hclparse"
)
type (
doc struct {
Tables []*sqlspec.Table `spec:"table"`
Enums []*Enum `spec:"enum"`
Schemas []*sqlspec.Schema `spec:"schema"`
}
// Enum holds a specification for an enum, that can be referenced as a column type.
Enum struct {
Name string `spec:",name"`
Schema *schemahcl.Ref `spec:"schema"`
Values []string `spec:"values"`
schemahcl.DefaultExtension
}
)
func init() {
schemahcl.Register("enum", &Enum{})
}
// evalSpec evaluates an Atlas DDL document into v using the input.
func evalSpec(p *hclparse.Parser, v any, input map[string]string) error {
var d doc
if err := hclState.Eval(p, &d, input); err != nil {
return err
}
switch v := v.(type) {
case *schema.Realm:
if err := specutil.Scan(v, d.Schemas, d.Tables, convertTable); err != nil {
return fmt.Errorf("specutil: failed converting to *schema.Realm: %w", err)
}
if len(d.Enums) > 0 {
if err := convertEnums(d.Tables, d.Enums, v); err != nil {
return err
}
}
case *schema.Schema:
if len(d.Schemas) != 1 {
return fmt.Errorf("specutil: expecting document to contain a single schema, got %d", len(d.Schemas))
}
r := &schema.Realm{}
if err := specutil.Scan(r, d.Schemas, d.Tables, convertTable); err != nil {
return err
}
if err := convertEnums(d.Tables, d.Enums, r); err != nil {
return err
}
*v = *r.Schemas[0]
default:
return fmt.Errorf("specutil: failed unmarshaling spec. %T is not supported", v)
}
return nil
}
// MarshalSpec marshals v into an Atlas DDL document using a schemahcl.Marshaler.
func MarshalSpec(v any, marshaler schemahcl.Marshaler) ([]byte, error) {
var d doc
switch s := v.(type) {
case *schema.Schema:
var err error
doc, err := schemaSpec(s)
if err != nil {
return nil, fmt.Errorf("specutil: failed converting schema to spec: %w", err)
}
d.Tables = doc.Tables
d.Schemas = doc.Schemas
d.Enums = doc.Enums
case *schema.Realm:
for _, s := range s.Schemas {
doc, err := schemaSpec(s)
if err != nil {
return nil, fmt.Errorf("specutil: failed converting schema to spec: %w", err)
}
d.Tables = append(d.Tables, doc.Tables...)
d.Schemas = append(d.Schemas, doc.Schemas...)
d.Enums = append(d.Enums, doc.Enums...)
}
if err := specutil.QualifyDuplicates(d.Tables); err != nil {
return nil, err
}
if err := specutil.QualifyReferences(d.Tables, s); err != nil {
return nil, err
}
default:
return nil, fmt.Errorf("specutil: failed marshaling spec. %T is not supported", v)
}
return marshaler.MarshalSpec(&d)
}
var (
hclState = schemahcl.New(
schemahcl.WithTypes(TypeRegistry.Specs()),
schemahcl.WithScopedEnums("table.index.type", IndexTypeBTree, IndexTypeHash, IndexTypeGIN, IndexTypeGiST, IndexTypeBRIN),
schemahcl.WithScopedEnums("table.partition.type", PartitionTypeRange, PartitionTypeList, PartitionTypeHash),
schemahcl.WithScopedEnums("table.column.identity.generated", GeneratedTypeAlways, GeneratedTypeByDefault),
schemahcl.WithScopedEnums("table.column.as.type", "STORED"),
schemahcl.WithScopedEnums("table.foreign_key.on_update", specutil.ReferenceVars...),
schemahcl.WithScopedEnums("table.foreign_key.on_delete", specutil.ReferenceVars...),
)
// MarshalHCL marshals v into an Atlas HCL DDL document.
MarshalHCL = schemahcl.MarshalerFunc(func(v any) ([]byte, error) {
return MarshalSpec(v, hclState)
})
// EvalHCL implements the schemahcl.Evaluator interface.
EvalHCL = schemahcl.EvalFunc(evalSpec)
// EvalHCLBytes is a helper that evaluates an HCL document from a byte slice instead
// of from an hclparse.Parser instance.
EvalHCLBytes = specutil.HCLBytesFunc(EvalHCL)
)
// convertTable converts a sqlspec.Table to a schema.Table. Table conversion is done without converting
// ForeignKeySpecs into ForeignKeys, as the target tables do not necessarily exist in the schema
// at this point. Instead, the linking is done by the convertSchema function.
func convertTable(spec *sqlspec.Table, parent *schema.Schema) (*schema.Table, error) {
t, err := specutil.Table(spec, parent, convertColumn, specutil.PrimaryKey, convertIndex, specutil.Check)
if err != nil {
return nil, err
}
if err := convertPartition(spec.Extra, t); err != nil {
return nil, err
}
return t, nil
}
// convertPartition converts and appends the partition block into the table attributes if exists.
func convertPartition(spec schemahcl.Resource, table *schema.Table) error {
r, ok := spec.Resource("partition")
if !ok {
return nil
}
var p struct {
Type string `spec:"type"`
Columns []*schemahcl.Ref `spec:"columns"`
Parts []*struct {
Expr string `spec:"expr"`
Column *schemahcl.Ref `spec:"column"`
} `spec:"by"`
}
if err := r.As(&p); err != nil {
return fmt.Errorf("parsing %s.partition: %w", table.Name, err)
}
if p.Type == "" {
return fmt.Errorf("missing attribute %s.partition.type", table.Name)
}
key := &Partition{T: p.Type}
switch n, m := len(p.Columns), len(p.Parts); {
case n == 0 && m == 0:
return fmt.Errorf("missing columns or expressions for %s.partition", table.Name)
case n > 0 && m > 0:
return fmt.Errorf(`multiple definitions for %s.partition, use "columns" or "by"`, table.Name)
case n > 0:
for _, r := range p.Columns {
c, err := specutil.ColumnByRef(table, r)
if err != nil {
return err
}
key.Parts = append(key.Parts, &PartitionPart{C: c})
}
case m > 0:
for i, p := range p.Parts {
switch {
case p.Column == nil && p.Expr == "":
return fmt.Errorf("missing column or expression for %s.partition.by at position %d", table.Name, i)
case p.Column != nil && p.Expr != "":
return fmt.Errorf("multiple definitions for %s.partition.by at position %d", table.Name, i)
case p.Column != nil:
c, err := specutil.ColumnByRef(table, p.Column)
if err != nil {
return err
}
key.Parts = append(key.Parts, &PartitionPart{C: c})
case p.Expr != "":
key.Parts = append(key.Parts, &PartitionPart{X: &schema.RawExpr{X: p.Expr}})
}
}
}
table.AddAttrs(key)
return nil
}
// fromPartition returns the resource spec for representing the partition block.
func fromPartition(p Partition) *schemahcl.Resource {
key := &schemahcl.Resource{
Type: "partition",
Attrs: []*schemahcl.Attr{
specutil.VarAttr("type", strings.ToUpper(specutil.Var(p.T))),
},
}
columns, ok := func() (*schemahcl.ListValue, bool) {
parts := make([]schemahcl.Value, 0, len(p.Parts))
for _, p := range p.Parts {
if p.C == nil {
return nil, false
}
parts = append(parts, specutil.ColumnRef(p.C.Name))
}
return &schemahcl.ListValue{V: parts}, true
}()
if ok {
key.Attrs = append(key.Attrs, &schemahcl.Attr{K: "columns", V: columns})
return key
}
for _, p := range p.Parts {
part := &schemahcl.Resource{Type: "by"}
switch {
case p.C != nil:
part.Attrs = append(part.Attrs, specutil.RefAttr("column", specutil.ColumnRef(p.C.Name)))
case p.X != nil:
part.Attrs = append(part.Attrs, specutil.StrAttr("expr", p.X.(*schema.RawExpr).X))
}
key.Children = append(key.Children, part)
}
return key
}
// convertColumn converts a sqlspec.Column into a schema.Column.
func convertColumn(spec *sqlspec.Column, _ *schema.Table) (*schema.Column, error) {
if err := fixDefaultQuotes(spec.Default); err != nil {
return nil, err
}
c, err := specutil.Column(spec, convertColumnType)
if err != nil {
return nil, err
}
if r, ok := spec.Extra.Resource("identity"); ok {
id, err := convertIdentity(r)
if err != nil {
return nil, err
}
c.Attrs = append(c.Attrs, id)
}
if err := specutil.ConvertGenExpr(spec.Remain(), c, generatedType); err != nil {
return nil, err
}
return c, nil
}
func convertIdentity(r *schemahcl.Resource) (*Identity, error) {
var spec struct {
Generation string `spec:"generated"`
Start int64 `spec:"start"`
Increment int64 `spec:"increment"`
}
if err := r.As(&spec); err != nil {
return nil, err
}
id := &Identity{Generation: specutil.FromVar(spec.Generation), Sequence: &Sequence{}}
if spec.Start != 0 {
id.Sequence.Start = spec.Start
}
if spec.Increment != 0 {
id.Sequence.Increment = spec.Increment
}
return id, nil
}
// fixDefaultQuotes fixes the quotes on the Default field to be single quotes
// instead of double quotes.
func fixDefaultQuotes(value schemahcl.Value) error {
lv, ok := value.(*schemahcl.LiteralValue)
if !ok {
return nil
}
if sqlx.IsQuoted(lv.V, '"') {
uq, err := strconv.Unquote(lv.V)
if err != nil {
return err
}
lv.V = "'" + uq + "'"
}
return nil
}
// convertIndex converts a sqlspec.Index into a schema.Index.
func convertIndex(spec *sqlspec.Index, t *schema.Table) (*schema.Index, error) {
idx, err := specutil.Index(spec, t)
if err != nil {
return nil, err
}
if attr, ok := spec.Attr("type"); ok {
t, err := attr.String()
if err != nil {
return nil, err
}
idx.Attrs = append(idx.Attrs, &IndexType{T: t})
}
if attr, ok := spec.Attr("where"); ok {
p, err := attr.String()
if err != nil {
return nil, err
}
idx.Attrs = append(idx.Attrs, &IndexPredicate{P: p})
}
if attr, ok := spec.Attr("page_per_range"); ok {
p, err := attr.Int64()
if err != nil {
return nil, err
}
idx.Attrs = append(idx.Attrs, &IndexStorageParams{PagesPerRange: p})
}
if attr, ok := spec.Attr("include"); ok {
refs, err := attr.Refs()
if err != nil {
return nil, err
}
if len(refs) == 0 {
return nil, fmt.Errorf("unexpected empty INCLUDE in index %q definition", spec.Name)
}
include := make([]*schema.Column, len(refs))
for i, r := range refs {
if include[i], err = specutil.ColumnByRef(t, r); err != nil {
return nil, err
}
}
idx.Attrs = append(idx.Attrs, &IndexInclude{Columns: include})
}
return idx, nil
}
const defaultTimePrecision = 6
// convertColumnType converts a sqlspec.Column into a concrete Postgres schema.Type.
func convertColumnType(spec *sqlspec.Column) (schema.Type, error) {
typ, err := TypeRegistry.Type(spec.Type, spec.Extra.Attrs)
if err != nil {
return nil, err
}
// Handle default values for time precision types.
if t, ok := typ.(*schema.TimeType); ok && strings.HasPrefix(t.T, "time") {
if _, ok := attr(spec.Type, "precision"); !ok {
p := defaultTimePrecision
t.Precision = &p
}
}
return typ, nil
}
// convertEnums converts possibly referenced column types (like enums) to
// an actual schema.Type and sets it on the correct schema.Column.
func convertEnums(tables []*sqlspec.Table, enums []*Enum, r *schema.Realm) error {
var (
used = make(map[*Enum]struct{})
byName = make(map[string]*Enum)
)
for _, e := range enums {
byName[e.Name] = e
}
for _, t := range tables {
for _, c := range t.Columns {
var enum *Enum
switch {
case c.Type.IsRef:
n, err := enumName(c.Type)
if err != nil {
return err
}
e, ok := byName[n]
if !ok {
return fmt.Errorf("enum %q was not found", n)
}
enum = e
default:
n, ok := arrayType(c.Type.T)
if !ok || byName[n] == nil {
continue
}
enum = byName[n]
}
used[enum] = struct{}{}
schemaE, err := specutil.SchemaName(enum.Schema)
if err != nil {
return fmt.Errorf("extract schema name from enum refrence: %w", err)
}
es, ok := r.Schema(schemaE)
if !ok {
return fmt.Errorf("schema %q not found in realm for table %q", schemaE, t.Name)
}
schemaT, err := specutil.SchemaName(t.Schema)
if err != nil {
return fmt.Errorf("extract schema name from table refrence: %w", err)
}
ts, ok := r.Schema(schemaT)
if !ok {
return fmt.Errorf("schema %q not found in realm for table %q", schemaT, t.Name)
}
tt, ok := ts.Table(t.Name)
if !ok {
return fmt.Errorf("table %q not found in schema %q", t.Name, ts.Name)
}
cc, ok := tt.Column(c.Name)
if !ok {
return fmt.Errorf("column %q not found in table %q", c.Name, t.Name)
}
e := &schema.EnumType{T: enum.Name, Schema: es, Values: enum.Values}
switch t := cc.Type.Type.(type) {
case *ArrayType:
t.Type = e
default:
cc.Type.Type = e
}
}
}
for _, e := range enums {
if _, ok := used[e]; !ok {
return fmt.Errorf("enum %q declared but not used", e.Name)
}
}
return nil
}
// enumName extracts the name of the referenced Enum from the reference string.
func enumName(ref *schemahcl.Type) (string, error) {
s := strings.Split(ref.T, "$enum.")
if len(s) != 2 {
return "", fmt.Errorf("postgres: failed to extract enum name from %q", ref.T)
}
return s[1], nil
}
// enumRef returns a reference string to the given enum name.
func enumRef(n string) *schemahcl.Ref {
return &schemahcl.Ref{
V: "$enum." + n,
}
}
// schemaSpec converts from a concrete Postgres schema to Atlas specification.
func schemaSpec(schem *schema.Schema) (*doc, error) {
s, tbls, err := specutil.FromSchema(schem, tableSpec)
if err != nil {
return nil, err
}
d := &doc{
Tables: tbls,
Schemas: []*sqlspec.Schema{s},
}
enums := make(map[string]bool)
for _, t := range schem.Tables {
for _, c := range t.Columns {
if e, ok := hasEnumType(c); ok && !enums[e.T] {
d.Enums = append(d.Enums, &Enum{
Name: e.T,
Schema: specutil.SchemaRef(s.Name),
Values: e.Values,
})
enums[e.T] = true
}
}
}
return d, nil
}
// tableSpec converts from a concrete Postgres sqlspec.Table to a schema.Table.
func tableSpec(table *schema.Table) (*sqlspec.Table, error) {
spec, err := specutil.FromTable(
table,
columnSpec,
specutil.FromPrimaryKey,
indexSpec,
specutil.FromForeignKey,
specutil.FromCheck,
)
if err != nil {
return nil, err
}
if p := (Partition{}); sqlx.Has(table.Attrs, &p) {
spec.Extra.Children = append(spec.Extra.Children, fromPartition(p))
}
return spec, nil
}
func indexSpec(idx *schema.Index) (*sqlspec.Index, error) {
spec, err := specutil.FromIndex(idx)
if err != nil {
return nil, err
}
// Avoid printing the index type if it is the default.
if i := (IndexType{}); sqlx.Has(idx.Attrs, &i) && i.T != IndexTypeBTree {
spec.Extra.Attrs = append(spec.Extra.Attrs, specutil.VarAttr("type", strings.ToUpper(i.T)))
}
if i := (IndexInclude{}); sqlx.Has(idx.Attrs, &i) && len(i.Columns) > 0 {
attr := &schemahcl.ListValue{}
for _, c := range i.Columns {
attr.V = append(attr.V, specutil.ColumnRef(c.Name))
}
spec.Extra.Attrs = append(spec.Extra.Attrs, &schemahcl.Attr{
K: "include",
V: attr,
})
}
if i := (IndexPredicate{}); sqlx.Has(idx.Attrs, &i) && i.P != "" {
spec.Extra.Attrs = append(spec.Extra.Attrs, specutil.VarAttr("where", strconv.Quote(i.P)))
}
if p, ok := indexStorageParams(idx.Attrs); ok {
spec.Extra.Attrs = append(spec.Extra.Attrs, specutil.Int64Attr("page_per_range", p.PagesPerRange))
}
return spec, nil
}
// columnSpec converts from a concrete Postgres schema.Column into a sqlspec.Column.
func columnSpec(c *schema.Column, _ *schema.Table) (*sqlspec.Column, error) {
s, err := specutil.FromColumn(c, columnTypeSpec)
if err != nil {
return nil, err
}
if i := (&Identity{}); sqlx.Has(c.Attrs, i) {
s.Extra.Children = append(s.Extra.Children, fromIdentity(i))
}
if x := (schema.GeneratedExpr{}); sqlx.Has(c.Attrs, &x) {
s.Extra.Children = append(s.Extra.Children, specutil.FromGenExpr(x, generatedType))
}
return s, nil
}
// fromIdentity returns the resource spec for representing the identity attributes.
func fromIdentity(i *Identity) *schemahcl.Resource {
id := &schemahcl.Resource{
Type: "identity",
Attrs: []*schemahcl.Attr{
specutil.VarAttr("generated", strings.ToUpper(specutil.Var(i.Generation))),
},
}
if s := i.Sequence; s != nil {
if s.Start != 1 {
id.Attrs = append(id.Attrs, specutil.Int64Attr("start", s.Start))
}
if s.Increment != 1 {
id.Attrs = append(id.Attrs, specutil.Int64Attr("increment", s.Increment))
}
}
return id
}
// columnTypeSpec converts from a concrete Postgres schema.Type into sqlspec.Column Type.
func columnTypeSpec(t schema.Type) (*sqlspec.Column, error) {
// Handle postgres enum types. They cannot be put into the TypeRegistry since their name is dynamic.
if e, ok := t.(*schema.EnumType); ok {
return &sqlspec.Column{Type: &schemahcl.Type{
T: enumRef(e.T).V,
IsRef: true,
}}, nil
}
st, err := TypeRegistry.Convert(t)
if err != nil {
return nil, err
}
return &sqlspec.Column{Type: st}, nil
}
// TypeRegistry contains the supported TypeSpecs for the Postgres driver.
var TypeRegistry = schemahcl.NewRegistry(
schemahcl.WithSpecFunc(typeSpec),
schemahcl.WithParser(ParseType),
schemahcl.WithSpecs(
schemahcl.NewTypeSpec(TypeBit, schemahcl.WithAttributes(&schemahcl.TypeAttr{Name: "len", Kind: reflect.Int64})),
schemahcl.AliasTypeSpec("bit_varying", TypeBitVar, schemahcl.WithAttributes(&schemahcl.TypeAttr{Name: "len", Kind: reflect.Int64})),
schemahcl.NewTypeSpec(TypeVarChar, schemahcl.WithAttributes(schemahcl.SizeTypeAttr(false))),
schemahcl.AliasTypeSpec("character_varying", TypeCharVar, schemahcl.WithAttributes(schemahcl.SizeTypeAttr(false))),
schemahcl.NewTypeSpec(TypeChar, schemahcl.WithAttributes(schemahcl.SizeTypeAttr(false))),
schemahcl.NewTypeSpec(TypeCharacter, schemahcl.WithAttributes(schemahcl.SizeTypeAttr(false))),
schemahcl.NewTypeSpec(TypeInt2),
schemahcl.NewTypeSpec(TypeInt4),
schemahcl.NewTypeSpec(TypeInt8),
schemahcl.NewTypeSpec(TypeInt),
schemahcl.NewTypeSpec(TypeInteger),
schemahcl.NewTypeSpec(TypeSmallInt),
schemahcl.NewTypeSpec(TypeBigInt),
schemahcl.NewTypeSpec(TypeText),
schemahcl.NewTypeSpec(TypeBoolean),
schemahcl.NewTypeSpec(TypeBool),
schemahcl.NewTypeSpec(TypeBytea),
schemahcl.NewTypeSpec(TypeCIDR),
schemahcl.NewTypeSpec(TypeInet),
schemahcl.NewTypeSpec(TypeMACAddr),
schemahcl.NewTypeSpec(TypeMACAddr8),
schemahcl.NewTypeSpec(TypeCircle),
schemahcl.NewTypeSpec(TypeLine),
schemahcl.NewTypeSpec(TypeLseg),
schemahcl.NewTypeSpec(TypeBox),
schemahcl.NewTypeSpec(TypePath),
schemahcl.NewTypeSpec(TypePoint),
schemahcl.NewTypeSpec(TypePolygon),
schemahcl.NewTypeSpec(TypeDate),
schemahcl.NewTypeSpec(TypeTime, schemahcl.WithAttributes(precisionTypeAttr()), formatTime()),
schemahcl.NewTypeSpec(TypeTimeTZ, schemahcl.WithAttributes(precisionTypeAttr()), formatTime()),
schemahcl.NewTypeSpec(TypeTimestampTZ, schemahcl.WithAttributes(precisionTypeAttr()), formatTime()),
schemahcl.NewTypeSpec(TypeTimestamp, schemahcl.WithAttributes(precisionTypeAttr()), formatTime()),
schemahcl.AliasTypeSpec("double_precision", TypeDouble),
schemahcl.NewTypeSpec(TypeReal),
schemahcl.NewTypeSpec(TypeFloat, schemahcl.WithAttributes(precisionTypeAttr())),
schemahcl.NewTypeSpec(TypeFloat8),
schemahcl.NewTypeSpec(TypeFloat4),
schemahcl.NewTypeSpec(TypeNumeric, schemahcl.WithAttributes(precisionTypeAttr(), &schemahcl.TypeAttr{Name: "scale", Kind: reflect.Int, Required: false})),
schemahcl.NewTypeSpec(TypeDecimal, schemahcl.WithAttributes(precisionTypeAttr(), &schemahcl.TypeAttr{Name: "scale", Kind: reflect.Int, Required: false})),
schemahcl.NewTypeSpec(TypeSmallSerial),
schemahcl.NewTypeSpec(TypeSerial),
schemahcl.NewTypeSpec(TypeBigSerial),
schemahcl.NewTypeSpec(TypeSerial2),
schemahcl.NewTypeSpec(TypeSerial4),
schemahcl.NewTypeSpec(TypeSerial8),
schemahcl.NewTypeSpec(TypeXML),
schemahcl.NewTypeSpec(TypeJSON),
schemahcl.NewTypeSpec(TypeJSONB),
schemahcl.NewTypeSpec(TypeUUID),
schemahcl.NewTypeSpec(TypeMoney),
schemahcl.NewTypeSpec("hstore"),
schemahcl.NewTypeSpec("sql", schemahcl.WithAttributes(&schemahcl.TypeAttr{Name: "def", Required: true, Kind: reflect.String})),
),
schemahcl.WithSpecs(func() (specs []*schemahcl.TypeSpec) {
opts := []schemahcl.TypeSpecOption{
schemahcl.WithToSpec(func(t schema.Type) (*schemahcl.Type, error) {
i, ok := t.(*IntervalType)
if !ok {
return nil, fmt.Errorf("postgres: unexpected interval type %T", t)
}
spec := &schemahcl.Type{T: TypeInterval}
if i.F != "" {
spec.T = specutil.Var(strings.ToLower(i.F))
}
if p := i.Precision; p != nil && *p != defaultTimePrecision {
spec.Attrs = []*schemahcl.Attr{specutil.IntAttr("precision", *p)}
}
return spec, nil
}),
schemahcl.WithFromSpec(func(t *schemahcl.Type) (schema.Type, error) {
i := &IntervalType{T: TypeInterval}
if t.T != TypeInterval {
i.F = specutil.FromVar(t.T)
}
if a, ok := attr(t, "precision"); ok {
p, err := a.Int()
if err != nil {
return nil, fmt.Errorf(`postgres: parsing attribute "precision": %w`, err)
}
if p != defaultTimePrecision {
i.Precision = &p
}
}
return i, nil
}),
}
for _, f := range []string{"interval", "second", "day to second", "hour to second", "minute to second"} {
specs = append(specs, schemahcl.NewTypeSpec(specutil.Var(f), append(opts, schemahcl.WithAttributes(precisionTypeAttr()))...))
}
for _, f := range []string{"year", "month", "day", "hour", "minute", "year to month", "day to hour", "day to minute", "hour to minute"} {
specs = append(specs, schemahcl.NewTypeSpec(specutil.Var(f), opts...))
}
return specs
}()...),
)
func precisionTypeAttr() *schemahcl.TypeAttr {
return &schemahcl.TypeAttr{
Name: "precision",
Kind: reflect.Int,
Required: false,
}
}
func attr(typ *schemahcl.Type, key string) (*schemahcl.Attr, bool) {
for _, a := range typ.Attrs {
if a.K == key {
return a, true
}
}
return nil, false
}
func typeSpec(t schema.Type) (*schemahcl.Type, error) {
if t, ok := t.(*schema.TimeType); ok && t.T != TypeDate {
spec := &schemahcl.Type{T: timeAlias(t.T)}
if p := t.Precision; p != nil && *p != defaultTimePrecision {
spec.Attrs = []*schemahcl.Attr{specutil.IntAttr("precision", *p)}
}
return spec, nil
}
s, err := FormatType(t)
if err != nil {
return nil, err
}
return &schemahcl.Type{T: s}, nil
}
// formatTime overrides the default printing logic done by schemahcl.hclType.
func formatTime() schemahcl.TypeSpecOption {
return schemahcl.WithTypeFormatter(func(t *schemahcl.Type) (string, error) {
a, ok := attr(t, "precision")
if !ok {
return t.T, nil
}
p, err := a.Int()
if err != nil {
return "", fmt.Errorf(`postgres: parsing attribute "precision": %w`, err)
}
return FormatType(&schema.TimeType{T: t.T, Precision: &p})
})
}
// generatedType returns the default and only type for a generated column.
func generatedType(string) string { return "STORED" }
atlas-0.7.2/sql/postgres/sqlspec_test.go 0000664 0000000 0000000 00000075303 14314555116 0020346 0 ustar 00root root 0000000 0000000 // Copyright 2021-present The Atlas Authors. All rights reserved.
// This source code is licensed under the Apache 2.0 license found
// in the LICENSE file in the root directory of this source tree.
package postgres
import (
"fmt"
"strconv"
"testing"
"ariga.io/atlas/sql/internal/spectest"
"ariga.io/atlas/sql/internal/sqlx"
"ariga.io/atlas/sql/schema"
"github.com/stretchr/testify/require"
)
func TestSQLSpec(t *testing.T) {
f := `
schema "schema" {
}
table "table" {
schema = schema.schema
column "col" {
type = integer
comment = "column comment"
}
column "age" {
type = integer
}
column "price" {
type = int
}
column "account_name" {
type = varchar(32)
}
column "varchar_length_is_not_required" {
type = varchar
}
column "character_varying_length_is_not_required" {
type = character_varying
}
column "tags" {
type = hstore
}
column "created_at" {
type = timestamp(4)
default = sql("current_timestamp(4)")
}
column "updated_at" {
type = time
default = sql("current_time")
}
primary_key {
columns = [table.table.column.col]
}
index "index" {
type = HASH
unique = true
columns = [
table.table.column.col,
table.table.column.age,
]
where = "active"
comment = "index comment"
}
foreign_key "accounts" {
columns = [
table.table.column.account_name,
]
ref_columns = [
table.accounts.column.name,
]
on_delete = SET_NULL
}
check "positive price" {
expr = "price > 0"
}
comment = "table comment"
}
table "accounts" {
schema = schema.schema
column "name" {
type = varchar(32)
}
column "type" {
type = enum.account_type
}
primary_key {
columns = [table.accounts.column.name]
}
}
enum "account_type" {
schema = schema.schema
values = ["private", "business"]
}
`
var s schema.Schema
err := EvalHCLBytes([]byte(f), &s, nil)
require.NoError(t, err)
exp := &schema.Schema{
Name: "schema",
}
exp.Tables = []*schema.Table{
{
Name: "table",
Schema: exp,
Columns: []*schema.Column{
{
Name: "col",
Type: &schema.ColumnType{
Type: &schema.IntegerType{
T: "integer",
},
},
Attrs: []schema.Attr{
&schema.Comment{Text: "column comment"},
},
},
{
Name: "age",
Type: &schema.ColumnType{
Type: &schema.IntegerType{
T: "integer",
},
},
},
{
Name: "price",
Type: &schema.ColumnType{
Type: &schema.IntegerType{
T: TypeInt,
},
},
},
{
Name: "account_name",
Type: &schema.ColumnType{
Type: &schema.StringType{
T: "varchar",
Size: 32,
},
},
},
{
Name: "varchar_length_is_not_required",
Type: &schema.ColumnType{
Type: &schema.StringType{
T: "varchar",
Size: 0,
},
},
},
{
Name: "character_varying_length_is_not_required",
Type: &schema.ColumnType{
Type: &schema.StringType{
T: "character varying",
Size: 0,
},
},
},
{
Name: "tags",
Type: &schema.ColumnType{
Type: &UserDefinedType{
T: "hstore",
},
},
},
{
Name: "created_at",
Type: &schema.ColumnType{
Type: typeTime(TypeTimestamp, 4),
},
Default: &schema.RawExpr{X: "current_timestamp(4)"},
},
{
Name: "updated_at",
Type: &schema.ColumnType{
Type: typeTime(TypeTime, 6),
},
Default: &schema.RawExpr{X: "current_time"},
},
},
Attrs: []schema.Attr{
&schema.Check{
Name: "positive price",
Expr: "price > 0",
},
&schema.Comment{Text: "table comment"},
},
},
{
Name: "accounts",
Schema: exp,
Columns: []*schema.Column{
{
Name: "name",
Type: &schema.ColumnType{
Type: &schema.StringType{
T: "varchar",
Size: 32,
},
},
},
{
Name: "type",
Type: &schema.ColumnType{
Type: &schema.EnumType{
T: "account_type",
Values: []string{"private", "business"},
Schema: exp,
},
},
},
},
},
}
exp.Tables[0].PrimaryKey = &schema.Index{
Table: exp.Tables[0],
Parts: []*schema.IndexPart{
{SeqNo: 0, C: exp.Tables[0].Columns[0]},
},
}
exp.Tables[0].Indexes = []*schema.Index{
{
Name: "index",
Table: exp.Tables[0],
Unique: true,
Parts: []*schema.IndexPart{
{SeqNo: 0, C: exp.Tables[0].Columns[0]},
{SeqNo: 1, C: exp.Tables[0].Columns[1]},
},
Attrs: []schema.Attr{
&schema.Comment{Text: "index comment"},
&IndexType{T: IndexTypeHash},
&IndexPredicate{P: "active"},
},
},
}
exp.Tables[0].ForeignKeys = []*schema.ForeignKey{
{
Symbol: "accounts",
Table: exp.Tables[0],
Columns: []*schema.Column{exp.Tables[0].Columns[3]},
RefTable: exp.Tables[1],
RefColumns: []*schema.Column{exp.Tables[1].Columns[0]},
OnDelete: schema.SetNull,
},
}
exp.Tables[1].PrimaryKey = &schema.Index{
Table: exp.Tables[1],
Parts: []*schema.IndexPart{
{SeqNo: 0, C: exp.Tables[1].Columns[0]},
},
}
exp.Realm = schema.NewRealm(exp)
require.EqualValues(t, exp, &s)
}
func TestUnmarshalSpec_IndexType(t *testing.T) {
f := `
schema "s" {}
table "t" {
schema = schema.s
column "c" {
type = int
}
index "i" {
type = %s
columns = [column.c]
}
}
`
t.Run("Invalid", func(t *testing.T) {
f := fmt.Sprintf(f, "UNK")
err := EvalHCLBytes([]byte(f), &schema.Schema{}, nil)
require.Error(t, err)
})
t.Run("Valid", func(t *testing.T) {
var (
s schema.Schema
f = fmt.Sprintf(f, "HASH")
)
err := EvalHCLBytes([]byte(f), &s, nil)
require.NoError(t, err)
idx := s.Tables[0].Indexes[0]
require.Equal(t, IndexTypeHash, idx.Attrs[0].(*IndexType).T)
})
}
func TestUnmarshalSpec_BRINIndex(t *testing.T) {
f := `
schema "s" {}
table "t" {
schema = schema.s
column "c" {
type = int
}
index "i" {
type = BRIN
columns = [column.c]
page_per_range = 2
}
}
`
var s schema.Schema
err := EvalHCLBytes([]byte(f), &s, nil)
require.NoError(t, err)
idx := s.Tables[0].Indexes[0]
require.Equal(t, IndexTypeBRIN, idx.Attrs[0].(*IndexType).T)
require.EqualValues(t, 2, idx.Attrs[1].(*IndexStorageParams).PagesPerRange)
}
func TestUnmarshalSpec_Partitioned(t *testing.T) {
t.Run("Columns", func(t *testing.T) {
var (
s = &schema.Schema{}
f = `
schema "test" {}
table "logs" {
schema = schema.test
column "name" {
type = text
}
partition {
type = HASH
columns = [
column.name
]
}
}
`
)
err := EvalHCLBytes([]byte(f), s, nil)
require.NoError(t, err)
c := schema.NewStringColumn("name", "text")
expected := schema.New("test").
AddTables(schema.NewTable("logs").AddColumns(c).AddAttrs(&Partition{T: PartitionTypeHash, Parts: []*PartitionPart{{C: c}}}))
expected.SetRealm(schema.NewRealm(expected))
require.Equal(t, expected, s)
})
t.Run("Parts", func(t *testing.T) {
var (
s = &schema.Schema{}
f = `
schema "test" {}
table "logs" {
schema = schema.test
column "name" {
type = text
}
partition {
type = RANGE
by {
column = column.name
}
by {
expr = "lower(name)"
}
}
}
`
)
err := EvalHCLBytes([]byte(f), s, nil)
require.NoError(t, err)
c := schema.NewStringColumn("name", "text")
expected := schema.New("test").
AddTables(schema.NewTable("logs").AddColumns(c).AddAttrs(&Partition{T: PartitionTypeRange, Parts: []*PartitionPart{{C: c}, {X: &schema.RawExpr{X: "lower(name)"}}}}))
expected.SetRealm(schema.NewRealm(expected))
require.Equal(t, expected, s)
})
t.Run("Invalid", func(t *testing.T) {
err := EvalHCLBytes([]byte(`
schema "test" {}
table "logs" {
schema = schema.test
column "name" { type = text }
partition {
columns = [column.name]
}
}
`), &schema.Schema{}, nil)
require.EqualError(t, err, "missing attribute logs.partition.type")
err = EvalHCLBytes([]byte(`
schema "test" {}
table "logs" {
schema = schema.test
column "name" { type = text }
partition {
type = HASH
}
}
`), &schema.Schema{}, nil)
require.EqualError(t, err, `missing columns or expressions for logs.partition`)
err = EvalHCLBytes([]byte(`
schema "test" {}
table "logs" {
schema = schema.test
column "name" { type = text }
partition {
type = HASH
columns = [column.name]
by { column = column.name }
}
}
`), &schema.Schema{}, nil)
require.EqualError(t, err, `multiple definitions for logs.partition, use "columns" or "by"`)
})
}
func TestMarshalSpec_Partitioned(t *testing.T) {
t.Run("Columns", func(t *testing.T) {
c := schema.NewStringColumn("name", "text")
s := schema.New("test").
AddTables(schema.NewTable("logs").AddColumns(c).AddAttrs(&Partition{T: PartitionTypeHash, Parts: []*PartitionPart{{C: c}}}))
buf, err := MarshalHCL(s)
require.NoError(t, err)
require.Equal(t, `table "logs" {
schema = schema.test
column "name" {
null = false
type = text
}
partition {
type = HASH
columns = [column.name]
}
}
schema "test" {
}
`, string(buf))
})
t.Run("Parts", func(t *testing.T) {
c := schema.NewStringColumn("name", "text")
s := schema.New("test").
AddTables(schema.NewTable("logs").AddColumns(c).AddAttrs(&Partition{T: PartitionTypeHash, Parts: []*PartitionPart{{C: c}, {X: &schema.RawExpr{X: "lower(name)"}}}}))
buf, err := MarshalHCL(s)
require.NoError(t, err)
require.Equal(t, `table "logs" {
schema = schema.test
column "name" {
null = false
type = text
}
partition {
type = HASH
by {
column = column.name
}
by {
expr = "lower(name)"
}
}
}
schema "test" {
}
`, string(buf))
})
}
func TestMarshalSpec_IndexPredicate(t *testing.T) {
s := &schema.Schema{
Name: "test",
Tables: []*schema.Table{
{
Name: "users",
Columns: []*schema.Column{
{
Name: "id",
Type: &schema.ColumnType{Type: &schema.IntegerType{T: "int"}},
},
},
},
},
}
s.Tables[0].Schema = s
s.Tables[0].Schema = s
s.Tables[0].Indexes = []*schema.Index{
{
Name: "index",
Table: s.Tables[0],
Unique: true,
Parts: []*schema.IndexPart{
{SeqNo: 0, C: s.Tables[0].Columns[0]},
},
Attrs: []schema.Attr{
&IndexPredicate{P: "id <> 0"},
},
},
}
buf, err := MarshalSpec(s, hclState)
require.NoError(t, err)
const expected = `table "users" {
schema = schema.test
column "id" {
null = false
type = int
}
index "index" {
unique = true
columns = [column.id]
where = "id <> 0"
}
}
schema "test" {
}
`
require.EqualValues(t, expected, string(buf))
}
func TestMarshalSpec_BRINIndex(t *testing.T) {
s := &schema.Schema{
Name: "test",
Tables: []*schema.Table{
{
Name: "users",
Columns: []*schema.Column{
{
Name: "id",
Type: &schema.ColumnType{Type: &schema.IntegerType{T: "int"}},
},
},
},
},
}
s.Tables[0].Schema = s
s.Tables[0].Schema = s
s.Tables[0].Indexes = []*schema.Index{
{
Name: "index",
Table: s.Tables[0],
Unique: true,
Parts: []*schema.IndexPart{
{SeqNo: 0, C: s.Tables[0].Columns[0]},
},
Attrs: []schema.Attr{
&IndexType{T: IndexTypeBRIN},
&IndexStorageParams{PagesPerRange: 2},
},
},
}
buf, err := MarshalSpec(s, hclState)
require.NoError(t, err)
const expected = `table "users" {
schema = schema.test
column "id" {
null = false
type = int
}
index "index" {
unique = true
columns = [column.id]
type = BRIN
page_per_range = 2
}
}
schema "test" {
}
`
require.EqualValues(t, expected, string(buf))
}
func TestUnmarshalSpec_Identity(t *testing.T) {
f := `
schema "s" {}
table "t" {
schema = schema.s
column "c" {
type = int
identity {
generated = %s
start = 10
}
}
}
`
t.Run("Invalid", func(t *testing.T) {
f := fmt.Sprintf(f, "UNK")
err := EvalHCLBytes([]byte(f), &schema.Schema{}, nil)
require.Error(t, err)
})
t.Run("Valid", func(t *testing.T) {
var (
s schema.Schema
f = fmt.Sprintf(f, "ALWAYS")
)
err := EvalHCLBytes([]byte(f), &s, nil)
require.NoError(t, err)
id := s.Tables[0].Columns[0].Attrs[0].(*Identity)
require.Equal(t, GeneratedTypeAlways, id.Generation)
require.EqualValues(t, 10, id.Sequence.Start)
require.Zero(t, id.Sequence.Increment)
})
}
func TestUnmarshalSpec_IndexInclude(t *testing.T) {
f := `
schema "s" {}
table "t" {
schema = schema.s
column "c" {
type = int
}
column "d" {
type = int
}
index "c" {
columns = [
column.c,
]
include = [
column.d,
]
}
}
`
var s schema.Schema
err := EvalHCLBytes([]byte(f), &s, nil)
require.NoError(t, err)
require.Len(t, s.Tables, 1)
require.Len(t, s.Tables[0].Columns, 2)
require.Len(t, s.Tables[0].Indexes, 1)
idx, ok := s.Tables[0].Index("c")
require.True(t, ok)
require.Len(t, idx.Parts, 1)
require.Len(t, idx.Attrs, 1)
var include IndexInclude
require.True(t, sqlx.Has(idx.Attrs, &include))
require.Len(t, include.Columns, 1)
require.Equal(t, "d", include.Columns[0].Name)
}
func TestMarshalSpec_IndexInclude(t *testing.T) {
s := &schema.Schema{
Name: "test",
Tables: []*schema.Table{
{
Name: "users",
Columns: []*schema.Column{
{
Name: "c",
Type: &schema.ColumnType{Type: &schema.IntegerType{T: "int"}},
},
{
Name: "d",
Type: &schema.ColumnType{Type: &schema.IntegerType{T: "int"}},
},
},
},
},
}
s.Tables[0].Schema = s
s.Tables[0].Schema = s
s.Tables[0].Indexes = []*schema.Index{
{
Name: "index",
Table: s.Tables[0],
Parts: []*schema.IndexPart{
{SeqNo: 0, C: s.Tables[0].Columns[0]},
},
Attrs: []schema.Attr{
&IndexInclude{Columns: s.Tables[0].Columns[1:]},
},
},
}
buf, err := MarshalSpec(s, hclState)
require.NoError(t, err)
const expected = `table "users" {
schema = schema.test
column "c" {
null = false
type = int
}
column "d" {
null = false
type = int
}
index "index" {
columns = [column.c]
include = [column.d]
}
}
schema "test" {
}
`
require.EqualValues(t, expected, string(buf))
}
func TestMarshalSpec_GeneratedColumn(t *testing.T) {
s := schema.New("test").
AddTables(
schema.NewTable("users").
AddColumns(
schema.NewIntColumn("c1", "int").
SetGeneratedExpr(&schema.GeneratedExpr{Expr: "c1 * 2"}),
schema.NewIntColumn("c2", "int").
SetGeneratedExpr(&schema.GeneratedExpr{Expr: "c3 * c4", Type: "STORED"}),
),
)
buf, err := MarshalSpec(s, hclState)
require.NoError(t, err)
const expected = `table "users" {
schema = schema.test
column "c1" {
null = false
type = int
as {
expr = "c1 * 2"
type = STORED
}
}
column "c2" {
null = false
type = int
as {
expr = "c3 * c4"
type = STORED
}
}
}
schema "test" {
}
`
require.EqualValues(t, expected, string(buf))
}
func TestUnmarshalSpec_GeneratedColumns(t *testing.T) {
var (
s schema.Schema
f = `
schema "test" {}
table "users" {
schema = schema.test
column "c1" {
type = int
as = "1"
}
column "c2" {
type = int
as {
expr = "2"
}
}
column "c3" {
type = int
as {
expr = "3"
type = STORED
}
}
}
`
)
err := EvalHCLBytes([]byte(f), &s, nil)
require.NoError(t, err)
expected := schema.New("test").
AddTables(
schema.NewTable("users").
AddColumns(
schema.NewIntColumn("c1", "int").SetGeneratedExpr(&schema.GeneratedExpr{Expr: "1", Type: "STORED"}),
schema.NewIntColumn("c2", "int").SetGeneratedExpr(&schema.GeneratedExpr{Expr: "2", Type: "STORED"}),
schema.NewIntColumn("c3", "int").SetGeneratedExpr(&schema.GeneratedExpr{Expr: "3", Type: "STORED"}),
),
)
expected.SetRealm(schema.NewRealm(expected))
require.EqualValues(t, expected, &s)
}
func TestMarshalSpec_Enum(t *testing.T) {
s := schema.New("test").
AddTables(
schema.NewTable("account").
AddColumns(
schema.NewEnumColumn("account_type",
schema.EnumName("account_type"),
schema.EnumValues("private", "business"),
),
schema.NewColumn("account_states").
SetType(&ArrayType{
T: "states[]",
Type: &schema.EnumType{
T: "state",
Values: []string{"on", "off"},
},
}),
),
schema.NewTable("table2").
AddColumns(
schema.NewEnumColumn("account_type",
schema.EnumName("account_type"),
schema.EnumValues("private", "business"),
),
),
)
buf, err := MarshalSpec(s, hclState)
require.NoError(t, err)
const expected = `table "account" {
schema = schema.test
column "account_type" {
null = false
type = enum.account_type
}
column "account_states" {
null = false
type = sql("states[]")
}
}
table "table2" {
schema = schema.test
column "account_type" {
null = false
type = enum.account_type
}
}
enum "account_type" {
schema = schema.test
values = ["private", "business"]
}
enum "state" {
schema = schema.test
values = ["on", "off"]
}
schema "test" {
}
`
require.EqualValues(t, expected, string(buf))
}
func TestMarshalSpec_TimePrecision(t *testing.T) {
s := schema.New("test").
AddTables(
schema.NewTable("times").
AddColumns(
schema.NewTimeColumn("t_time_def", TypeTime),
schema.NewTimeColumn("t_time_with_time_zone", TypeTimeTZ, schema.TimePrecision(2)),
schema.NewTimeColumn("t_time_without_time_zone", TypeTime, schema.TimePrecision(2)),
schema.NewTimeColumn("t_timestamp", TypeTimestamp, schema.TimePrecision(2)),
schema.NewTimeColumn("t_timestamptz", TypeTimestampTZ, schema.TimePrecision(2)),
),
)
buf, err := MarshalSpec(s, hclState)
require.NoError(t, err)
const expected = `table "times" {
schema = schema.test
column "t_time_def" {
null = false
type = time
}
column "t_time_with_time_zone" {
null = false
type = timetz(2)
}
column "t_time_without_time_zone" {
null = false
type = time(2)
}
column "t_timestamp" {
null = false
type = timestamp(2)
}
column "t_timestamptz" {
null = false
type = timestamptz(2)
}
}
schema "test" {
}
`
require.EqualValues(t, expected, string(buf))
}
func TestTypes(t *testing.T) {
p := func(i int) *int { return &i }
for _, tt := range []struct {
typeExpr string
expected schema.Type
}{
{
typeExpr: "bit(10)",
expected: &BitType{T: TypeBit, Len: 10},
},
{
typeExpr: `hstore`,
expected: &UserDefinedType{T: "hstore"},
},
{
typeExpr: "bit_varying(10)",
expected: &BitType{T: TypeBitVar, Len: 10},
},
{
typeExpr: "boolean",
expected: &schema.BoolType{T: TypeBoolean},
},
{
typeExpr: "bool",
expected: &schema.BoolType{T: TypeBool},
},
{
typeExpr: "bytea",
expected: &schema.BinaryType{T: TypeBytea},
},
{
typeExpr: "varchar(255)",
expected: &schema.StringType{T: TypeVarChar, Size: 255},
},
{
typeExpr: "char(255)",
expected: &schema.StringType{T: TypeChar, Size: 255},
},
{
typeExpr: "character(255)",
expected: &schema.StringType{T: TypeCharacter, Size: 255},
},
{
typeExpr: "text",
expected: &schema.StringType{T: TypeText},
},
{
typeExpr: "smallint",
expected: &schema.IntegerType{T: TypeSmallInt},
},
{
typeExpr: "integer",
expected: &schema.IntegerType{T: TypeInteger},
},
{
typeExpr: "bigint",
expected: &schema.IntegerType{T: TypeBigInt},
},
{
typeExpr: "int",
expected: &schema.IntegerType{T: TypeInt},
},
{
typeExpr: "int2",
expected: &schema.IntegerType{T: TypeInt2},
},
{
typeExpr: "int4",
expected: &schema.IntegerType{T: TypeInt4},
},
{
typeExpr: "int8",
expected: &schema.IntegerType{T: TypeInt8},
},
{
typeExpr: "cidr",
expected: &NetworkType{T: TypeCIDR},
},
{
typeExpr: "inet",
expected: &NetworkType{T: TypeInet},
},
{
typeExpr: "macaddr",
expected: &NetworkType{T: TypeMACAddr},
},
{
typeExpr: "macaddr8",
expected: &NetworkType{T: TypeMACAddr8},
},
{
typeExpr: "circle",
expected: &schema.SpatialType{T: TypeCircle},
},
{
typeExpr: "line",
expected: &schema.SpatialType{T: TypeLine},
},
{
typeExpr: "lseg",
expected: &schema.SpatialType{T: TypeLseg},
},
{
typeExpr: "box",
expected: &schema.SpatialType{T: TypeBox},
},
{
typeExpr: "path",
expected: &schema.SpatialType{T: TypePath},
},
{
typeExpr: "point",
expected: &schema.SpatialType{T: TypePoint},
},
{
typeExpr: "date",
expected: &schema.TimeType{T: TypeDate},
},
{
typeExpr: "time",
expected: typeTime(TypeTime, 6),
},
{
typeExpr: "time(4)",
expected: typeTime(TypeTime, 4),
},
{
typeExpr: "timetz",
expected: typeTime(TypeTimeTZ, 6),
},
{
typeExpr: "timestamp",
expected: typeTime(TypeTimestamp, 6),
},
{
typeExpr: "timestamp(4)",
expected: typeTime(TypeTimestamp, 4),
},
{
typeExpr: "timestamptz",
expected: typeTime(TypeTimestampTZ, 6),
},
{
typeExpr: "timestamptz(4)",
expected: typeTime(TypeTimestampTZ, 4),
},
{
typeExpr: "interval",
expected: &IntervalType{T: "interval"},
},
{
typeExpr: "interval(1)",
expected: &IntervalType{T: "interval", Precision: p(1)},
},
{
typeExpr: "second",
expected: &IntervalType{T: "interval", F: "second"},
},
{
typeExpr: "minute_to_second",
expected: &IntervalType{T: "interval", F: "minute to second"},
},
{
typeExpr: "minute_to_second(2)",
expected: &IntervalType{T: "interval", F: "minute to second", Precision: p(2)},
},
{
typeExpr: "real",
expected: &schema.FloatType{T: TypeReal, Precision: 24},
},
{
typeExpr: "float",
expected: &schema.FloatType{T: TypeFloat},
},
{
typeExpr: "float(1)",
expected: &schema.FloatType{T: TypeFloat, Precision: 1},
},
{
typeExpr: "float(25)",
expected: &schema.FloatType{T: TypeFloat, Precision: 25},
},
{
typeExpr: "float8",
expected: &schema.FloatType{T: TypeFloat8, Precision: 53},
},
{
typeExpr: "float4",
expected: &schema.FloatType{T: TypeFloat4, Precision: 24},
},
{
typeExpr: "numeric",
expected: &schema.DecimalType{T: TypeNumeric},
},
{
typeExpr: "numeric(10)",
expected: &schema.DecimalType{T: TypeNumeric, Precision: 10},
},
{
typeExpr: "numeric(10, 2)",
expected: &schema.DecimalType{T: TypeNumeric, Precision: 10, Scale: 2},
},
{
typeExpr: "decimal",
expected: &schema.DecimalType{T: TypeDecimal},
},
{
typeExpr: "decimal(10)",
expected: &schema.DecimalType{T: TypeDecimal, Precision: 10},
},
{
typeExpr: "decimal(10,2)",
expected: &schema.DecimalType{T: TypeDecimal, Precision: 10, Scale: 2},
},
{
typeExpr: "smallserial",
expected: &SerialType{T: TypeSmallSerial},
},
{
typeExpr: "serial",
expected: &SerialType{T: TypeSerial},
},
{
typeExpr: "bigserial",
expected: &SerialType{T: TypeBigSerial},
},
{
typeExpr: "serial2",
expected: &SerialType{T: TypeSerial2},
},
{
typeExpr: "serial4",
expected: &SerialType{T: TypeSerial4},
},
{
typeExpr: "serial8",
expected: &SerialType{T: TypeSerial8},
},
{
typeExpr: "xml",
expected: &XMLType{T: TypeXML},
},
{
typeExpr: "json",
expected: &schema.JSONType{T: TypeJSON},
},
{
typeExpr: "jsonb",
expected: &schema.JSONType{T: TypeJSONB},
},
{
typeExpr: "uuid",
expected: &UUIDType{T: TypeUUID},
},
{
typeExpr: "money",
expected: &CurrencyType{T: TypeMoney},
},
{
typeExpr: `sql("int[]")`,
expected: &ArrayType{Type: &schema.IntegerType{T: "int"}, T: "int[]"},
},
{
typeExpr: `sql("int[2]")`,
expected: &ArrayType{Type: &schema.IntegerType{T: "int"}, T: "int[]"},
},
{
typeExpr: `sql("text[][]")`,
expected: &ArrayType{Type: &schema.StringType{T: "text"}, T: "text[]"},
},
{
typeExpr: `sql("integer [3][3]")`,
expected: &ArrayType{Type: &schema.IntegerType{T: "integer"}, T: "integer[]"},
},
{
typeExpr: `sql("integer ARRAY[4]")`,
expected: &ArrayType{Type: &schema.IntegerType{T: "integer"}, T: "integer[]"},
},
{
typeExpr: `sql("integer ARRAY")`,
expected: &ArrayType{Type: &schema.IntegerType{T: "integer"}, T: "integer[]"},
},
{
typeExpr: `sql("character varying(255) [1][2]")`,
expected: &ArrayType{Type: &schema.StringType{T: "character varying", Size: 255}, T: "character varying(255)[]"},
},
{
typeExpr: `sql("character varying ARRAY[2]")`,
expected: &ArrayType{Type: &schema.StringType{T: "character varying"}, T: "character varying[]"},
},
{
typeExpr: `sql("varchar(2) [ 2 ] [ ]")`,
expected: &ArrayType{Type: &schema.StringType{T: "varchar", Size: 2}, T: "varchar(2)[]"},
},
} {
t.Run(tt.typeExpr, func(t *testing.T) {
var test schema.Schema
doc := fmt.Sprintf(`table "test" {
schema = schema.test
column "test" {
null = false
type = %s
}
}
schema "test" {
}
`, tt.typeExpr)
err := EvalHCLBytes([]byte(doc), &test, nil)
require.NoError(t, err)
colspec := test.Tables[0].Columns[0]
require.EqualValues(t, tt.expected, colspec.Type.Type)
spec, err := MarshalHCL(&test)
require.NoError(t, err)
var after schema.Schema
err = EvalHCLBytes(spec, &after, nil)
require.NoError(t, err)
require.EqualValues(t, tt.expected, after.Tables[0].Columns[0].Type.Type)
})
}
}
func typeTime(t string, p int) schema.Type {
return &schema.TimeType{T: t, Precision: &p}
}
func TestParseType_Time(t *testing.T) {
for _, tt := range []struct {
typ string
expected schema.Type
}{
{
typ: "timestamptz",
expected: typeTime(TypeTimestampTZ, 6),
},
{
typ: "timestamptz(0)",
expected: typeTime(TypeTimestampTZ, 0),
},
{
typ: "timestamptz(6)",
expected: typeTime(TypeTimestampTZ, 6),
},
{
typ: "timestamp with time zone",
expected: typeTime(TypeTimestampTZ, 6),
},
{
typ: "timestamp(1) with time zone",
expected: typeTime(TypeTimestampTZ, 1),
},
{
typ: "timestamp",
expected: typeTime(TypeTimestamp, 6),
},
{
typ: "timestamp(0)",
expected: typeTime(TypeTimestamp, 0),
},
{
typ: "timestamp(6)",
expected: typeTime(TypeTimestamp, 6),
},
{
typ: "timestamp without time zone",
expected: typeTime(TypeTimestamp, 6),
},
{
typ: "timestamp(1) without time zone",
expected: typeTime(TypeTimestamp, 1),
},
{
typ: "time",
expected: typeTime(TypeTime, 6),
},
{
typ: "time(3)",
expected: typeTime(TypeTime, 3),
},
{
typ: "time without time zone",
expected: typeTime(TypeTime, 6),
},
{
typ: "time(3) without time zone",
expected: typeTime(TypeTime, 3),
},
{
typ: "timetz",
expected: typeTime(TypeTimeTZ, 6),
},
{
typ: "timetz(4)",
expected: typeTime(TypeTimeTZ, 4),
},
{
typ: "time with time zone",
expected: typeTime(TypeTimeTZ, 6),
},
{
typ: "time(4) with time zone",
expected: typeTime(TypeTimeTZ, 4),
},
} {
t.Run(tt.typ, func(t *testing.T) {
typ, err := ParseType(tt.typ)
require.NoError(t, err)
require.Equal(t, tt.expected, typ)
})
}
}
func TestFormatType_Interval(t *testing.T) {
p := func(i int) *int { return &i }
for i, tt := range []struct {
typ *IntervalType
fmt string
}{
{
typ: &IntervalType{T: "interval"},
fmt: "interval",
},
{
typ: &IntervalType{T: "interval", Precision: p(6)},
fmt: "interval",
},
{
typ: &IntervalType{T: "interval", Precision: p(3)},
fmt: "interval(3)",
},
{
typ: &IntervalType{T: "interval", F: "DAY"},
fmt: "interval day",
},
{
typ: &IntervalType{T: "interval", F: "HOUR TO SECOND"},
fmt: "interval hour to second",
},
{
typ: &IntervalType{T: "interval", F: "HOUR TO SECOND", Precision: p(2)},
fmt: "interval hour to second(2)",
},
{
typ: &IntervalType{T: "interval", F: "DAY TO HOUR", Precision: p(6)},
fmt: "interval day to hour",
},
} {
t.Run(strconv.Itoa(i), func(t *testing.T) {
f, err := FormatType(tt.typ)
require.NoError(t, err)
require.Equal(t, tt.fmt, f)
})
}
}
func TestParseType_Interval(t *testing.T) {
p := func(i int) *int { return &i }
for i, tt := range []struct {
typ string
parsed *IntervalType
}{
{
typ: "interval",
parsed: &IntervalType{T: "interval", Precision: p(6)},
},
{
typ: "interval(2)",
parsed: &IntervalType{T: "interval", Precision: p(2)},
},
{
typ: "interval day",
parsed: &IntervalType{T: "interval", F: "day", Precision: p(6)},
},
{
typ: "interval day to second(2)",
parsed: &IntervalType{T: "interval", F: "day to second", Precision: p(2)},
},
{
typ: "interval day to second (2)",
parsed: &IntervalType{T: "interval", F: "day to second", Precision: p(2)},
},
} {
t.Run(strconv.Itoa(i), func(t *testing.T) {
p, err := ParseType(tt.typ)
require.NoError(t, err)
require.Equal(t, tt.parsed, p)
})
}
}
func TestRegistrySanity(t *testing.T) {
spectest.RegistrySanityTest(t, TypeRegistry, []string{"enum"})
}
func TestInputVars(t *testing.T) {
spectest.TestInputVars(t, EvalHCL)
}
func TestMarshalRealm(t *testing.T) {
t1 := schema.NewTable("t1").
AddColumns(schema.NewIntColumn("id", "int"))
t2 := schema.NewTable("t2").
SetComment("Qualified with s1").
AddColumns(schema.NewIntColumn("oid", "int"))
t2.AddForeignKeys(schema.NewForeignKey("oid2id").AddColumns(t2.Columns[0]).SetRefTable(t1).AddRefColumns(t1.Columns[0]))
t3 := schema.NewTable("t3").
AddColumns(schema.NewIntColumn("id", "int"))
t4 := schema.NewTable("t2").
SetComment("Qualified with s2").
AddColumns(schema.NewIntColumn("oid", "int"))
t4.AddForeignKeys(schema.NewForeignKey("oid2id").AddColumns(t4.Columns[0]).SetRefTable(t3).AddRefColumns(t3.Columns[0]))
t5 := schema.NewTable("t5").
AddColumns(schema.NewIntColumn("oid", "int"))
t5.AddForeignKeys(schema.NewForeignKey("oid2id1").AddColumns(t5.Columns[0]).SetRefTable(t1).AddRefColumns(t1.Columns[0]))
// Reference is qualified with s1.
t5.AddForeignKeys(schema.NewForeignKey("oid2id2").AddColumns(t5.Columns[0]).SetRefTable(t2).AddRefColumns(t2.Columns[0]))
r := schema.NewRealm(
schema.New("s1").AddTables(t1, t2),
schema.New("s2").AddTables(t3, t4, t5),
)
got, err := MarshalHCL.MarshalSpec(r)
require.NoError(t, err)
require.Equal(
t,
`table "t1" {
schema = schema.s1
column "id" {
null = false
type = int
}
}
table "s1" "t2" {
schema = schema.s1
comment = "Qualified with s1"
column "oid" {
null = false
type = int
}
foreign_key "oid2id" {
columns = [column.oid]
ref_columns = [table.t1.column.id]
}
}
table "t3" {
schema = schema.s2
column "id" {
null = false
type = int
}
}
table "s2" "t2" {
schema = schema.s2
comment = "Qualified with s2"
column "oid" {
null = false
type = int
}
foreign_key "oid2id" {
columns = [column.oid]
ref_columns = [table.t3.column.id]
}
}
table "t5" {
schema = schema.s2
column "oid" {
null = false
type = int
}
foreign_key "oid2id1" {
columns = [column.oid]
ref_columns = [table.t1.column.id]
}
foreign_key "oid2id2" {
columns = [column.oid]
ref_columns = [table.s1.t2.column.oid]
}
}
schema "s1" {
}
schema "s2" {
}
`,
string(got))
}
atlas-0.7.2/sql/schema/ 0000775 0000000 0000000 00000000000 14314555116 0014670 5 ustar 00root root 0000000 0000000 atlas-0.7.2/sql/schema/dsl.go 0000664 0000000 0000000 00000046021 14314555116 0016004 0 ustar 00root root 0000000 0000000 // Copyright 2021-present The Atlas Authors. All rights reserved.
// This source code is licensed under the Apache 2.0 license found
// in the LICENSE file in the root directory of this source tree.
package schema
import (
"reflect"
)
// The functions and methods below provide a DSL for creating schema resources using
// a fluent interface. Note that some methods create links between the schema elements.
// New creates a new Schema.
func New(name string) *Schema {
return &Schema{Name: name}
}
// SetCharset sets or appends the Charset attribute
// to the schema with the given value.
func (s *Schema) SetCharset(v string) *Schema {
replaceOrAppend(&s.Attrs, &Charset{V: v})
return s
}
// UnsetCharset unsets the Charset attribute.
func (s *Schema) UnsetCharset() *Schema {
del(&s.Attrs, &Charset{})
return s
}
// SetCollation sets or appends the Collation attribute
// to the schema with the given value.
func (s *Schema) SetCollation(v string) *Schema {
replaceOrAppend(&s.Attrs, &Collation{V: v})
return s
}
// UnsetCollation the Collation attribute.
func (s *Schema) UnsetCollation() *Schema {
del(&s.Attrs, &Collation{})
return s
}
// SetComment sets or appends the Comment attribute
// to the schema with the given value.
func (s *Schema) SetComment(v string) *Schema {
replaceOrAppend(&s.Attrs, &Comment{Text: v})
return s
}
// AddAttrs adds additional attributes to the schema.
func (s *Schema) AddAttrs(attrs ...Attr) *Schema {
s.Attrs = append(s.Attrs, attrs...)
return s
}
// SetRealm sets the database/realm of the schema.
func (s *Schema) SetRealm(r *Realm) *Schema {
s.Realm = r
return s
}
// AddTables adds and links the given tables to the schema.
func (s *Schema) AddTables(tables ...*Table) *Schema {
for _, t := range tables {
t.SetSchema(s)
}
s.Tables = append(s.Tables, tables...)
return s
}
// NewRealm creates a new Realm.
func NewRealm(schemas ...*Schema) *Realm {
r := &Realm{Schemas: schemas}
for _, s := range schemas {
s.Realm = r
}
return r
}
// AddSchemas adds and links the given schemas to the realm.
func (r *Realm) AddSchemas(schemas ...*Schema) *Realm {
for _, s := range schemas {
s.SetRealm(r)
}
r.Schemas = append(r.Schemas, schemas...)
return r
}
// SetCharset sets or appends the Charset attribute
// to the realm with the given value.
func (r *Realm) SetCharset(v string) *Realm {
replaceOrAppend(&r.Attrs, &Charset{V: v})
return r
}
// UnsetCharset unsets the Charset attribute.
func (r *Realm) UnsetCharset() *Realm {
del(&r.Attrs, &Charset{})
return r
}
// SetCollation sets or appends the Collation attribute
// to the realm with the given value.
func (r *Realm) SetCollation(v string) *Realm {
replaceOrAppend(&r.Attrs, &Collation{V: v})
return r
}
// UnsetCollation the Collation attribute.
func (r *Realm) UnsetCollation() *Realm {
del(&r.Attrs, &Collation{})
return r
}
// NewTable creates a new Table.
func NewTable(name string) *Table {
return &Table{Name: name}
}
// SetCharset sets or appends the Charset attribute
// to the table with the given value.
func (t *Table) SetCharset(v string) *Table {
replaceOrAppend(&t.Attrs, &Charset{V: v})
return t
}
// UnsetCharset unsets the Charset attribute.
func (t *Table) UnsetCharset() *Table {
del(&t.Attrs, &Charset{})
return t
}
// SetCollation sets or appends the Collation attribute
// to the table with the given value.
func (t *Table) SetCollation(v string) *Table {
replaceOrAppend(&t.Attrs, &Collation{V: v})
return t
}
// UnsetCollation the Collation attribute.
func (t *Table) UnsetCollation() *Table {
del(&t.Attrs, &Collation{})
return t
}
// SetComment sets or appends the Comment attribute
// to the table with the given value.
func (t *Table) SetComment(v string) *Table {
replaceOrAppend(&t.Attrs, &Comment{Text: v})
return t
}
// AddChecks appends the given checks to the attribute list.
func (t *Table) AddChecks(checks ...*Check) *Table {
for _, c := range checks {
t.Attrs = append(t.Attrs, c)
}
return t
}
// SetSchema sets the schema (named-database) of the table.
func (t *Table) SetSchema(s *Schema) *Table {
t.Schema = s
return t
}
// SetPrimaryKey sets the primary-key of the table.
func (t *Table) SetPrimaryKey(pk *Index) *Table {
pk.Table = t
t.PrimaryKey = pk
for _, p := range pk.Parts {
if p.C == nil {
continue
}
if _, ok := t.Column(p.C.Name); !ok {
t.AddColumns(p.C)
}
}
return t
}
// AddColumns appends the given columns to the table column list.
func (t *Table) AddColumns(columns ...*Column) *Table {
t.Columns = append(t.Columns, columns...)
return t
}
// AddIndexes appends the given indexes to the table index list.
func (t *Table) AddIndexes(indexes ...*Index) *Table {
for _, idx := range indexes {
idx.Table = t
}
t.Indexes = append(t.Indexes, indexes...)
return t
}
// AddForeignKeys appends the given foreign-keys to the table foreign-key list.
func (t *Table) AddForeignKeys(fks ...*ForeignKey) *Table {
for _, fk := range fks {
fk.Table = t
}
t.ForeignKeys = append(t.ForeignKeys, fks...)
return t
}
// AddAttrs adds and additional attributes to the table.
func (t *Table) AddAttrs(attrs ...Attr) *Table {
t.Attrs = append(t.Attrs, attrs...)
return t
}
// NewColumn creates a new column with the given name.
func NewColumn(name string) *Column {
return &Column{Name: name}
}
// NewNullColumn creates a new nullable column with the given name.
func NewNullColumn(name string) *Column {
return NewColumn(name).
SetNull(true)
}
// NewBoolColumn creates a new BoolType column.
func NewBoolColumn(name, typ string) *Column {
return NewColumn(name).
SetType(&BoolType{T: typ})
}
// NewNullBoolColumn creates a new nullable BoolType column.
func NewNullBoolColumn(name, typ string) *Column {
return NewBoolColumn(name, typ).
SetNull(true)
}
// NewIntColumn creates a new IntegerType column.
func NewIntColumn(name, typ string) *Column {
return NewColumn(name).
SetType(&IntegerType{T: typ})
}
// NewNullIntColumn creates a new nullable IntegerType column.
func NewNullIntColumn(name, typ string) *Column {
return NewIntColumn(name, typ).
SetNull(true)
}
// NewUintColumn creates a new unsigned IntegerType column.
func NewUintColumn(name, typ string) *Column {
return NewColumn(name).
SetType(&IntegerType{T: typ, Unsigned: true})
}
// NewNullUintColumn creates a new nullable unsigned IntegerType column.
func NewNullUintColumn(name, typ string) *Column {
return NewUintColumn(name, typ).
SetNull(true)
}
// EnumOption allows configuring EnumType using functional options.
type EnumOption func(*EnumType)
// EnumName configures the name of the name. This option
// is useful for databases like PostgreSQL that supports
// user-defined types for enums.
func EnumName(name string) EnumOption {
return func(e *EnumType) {
e.T = name
}
}
// EnumValues configures the values of the enum.
func EnumValues(values ...string) EnumOption {
return func(e *EnumType) {
e.Values = values
}
}
// EnumSchema configures the schema of the enum.
func EnumSchema(s *Schema) EnumOption {
return func(e *EnumType) {
e.Schema = s
}
}
// NewEnumColumn creates a new EnumType column.
func NewEnumColumn(name string, opts ...EnumOption) *Column {
t := &EnumType{}
for _, opt := range opts {
opt(t)
}
return NewColumn(name).SetType(t)
}
// NewNullEnumColumn creates a new nullable EnumType column.
func NewNullEnumColumn(name string, opts ...EnumOption) *Column {
return NewEnumColumn(name, opts...).
SetNull(true)
}
// BinaryOption allows configuring BinaryType using functional options.
type BinaryOption func(*BinaryType)
// BinarySize configures the size of the binary type.
func BinarySize(size int) BinaryOption {
return func(b *BinaryType) {
b.Size = &size
}
}
// NewBinaryColumn creates a new BinaryType column.
func NewBinaryColumn(name, typ string, opts ...BinaryOption) *Column {
t := &BinaryType{T: typ}
for _, opt := range opts {
opt(t)
}
return NewColumn(name).SetType(t)
}
// NewNullBinaryColumn creates a new nullable BinaryType column.
func NewNullBinaryColumn(name, typ string, opts ...BinaryOption) *Column {
return NewBinaryColumn(name, typ, opts...).
SetNull(true)
}
// StringOption allows configuring StringType using functional options.
type StringOption func(*StringType)
// StringSize configures the size of the string type.
func StringSize(size int) StringOption {
return func(b *StringType) {
b.Size = size
}
}
// NewStringColumn creates a new StringType column.
func NewStringColumn(name, typ string, opts ...StringOption) *Column {
t := &StringType{T: typ}
for _, opt := range opts {
opt(t)
}
return NewColumn(name).SetType(t)
}
// NewNullStringColumn creates a new nullable StringType column.
func NewNullStringColumn(name, typ string, opts ...StringOption) *Column {
return NewStringColumn(name, typ, opts...).
SetNull(true)
}
// DecimalOption allows configuring DecimalType using functional options.
type DecimalOption func(*DecimalType)
// DecimalPrecision configures the precision of the decimal type.
func DecimalPrecision(precision int) DecimalOption {
return func(b *DecimalType) {
b.Precision = precision
}
}
// DecimalScale configures the scale of the decimal type.
func DecimalScale(scale int) DecimalOption {
return func(b *DecimalType) {
b.Scale = scale
}
}
// DecimalUnsigned configures the unsigned of the float type.
func DecimalUnsigned(unsigned bool) DecimalOption {
return func(b *DecimalType) {
b.Unsigned = unsigned
}
}
// NewDecimalColumn creates a new DecimalType column.
func NewDecimalColumn(name, typ string, opts ...DecimalOption) *Column {
t := &DecimalType{T: typ}
for _, opt := range opts {
opt(t)
}
return NewColumn(name).SetType(t)
}
// NewNullDecimalColumn creates a new nullable DecimalType column.
func NewNullDecimalColumn(name, typ string, opts ...DecimalOption) *Column {
return NewDecimalColumn(name, typ, opts...).
SetNull(true)
}
// FloatOption allows configuring FloatType using functional options.
type FloatOption func(*FloatType)
// FloatPrecision configures the precision of the float type.
func FloatPrecision(precision int) FloatOption {
return func(b *FloatType) {
b.Precision = precision
}
}
// FloatUnsigned configures the unsigned of the float type.
func FloatUnsigned(unsigned bool) FloatOption {
return func(b *FloatType) {
b.Unsigned = unsigned
}
}
// NewFloatColumn creates a new FloatType column.
func NewFloatColumn(name, typ string, opts ...FloatOption) *Column {
t := &FloatType{T: typ}
for _, opt := range opts {
opt(t)
}
return NewColumn(name).SetType(t)
}
// NewNullFloatColumn creates a new nullable FloatType column.
func NewNullFloatColumn(name, typ string, opts ...FloatOption) *Column {
return NewFloatColumn(name, typ, opts...).
SetNull(true)
}
// TimeOption allows configuring TimeType using functional options.
type TimeOption func(*TimeType)
// TimePrecision configures the precision of the time type.
func TimePrecision(precision int) TimeOption {
return func(b *TimeType) {
b.Precision = &precision
}
}
// NewTimeColumn creates a new TimeType column.
func NewTimeColumn(name, typ string, opts ...TimeOption) *Column {
t := &TimeType{T: typ}
for _, opt := range opts {
opt(t)
}
return NewColumn(name).SetType(t)
}
// NewNullTimeColumn creates a new nullable TimeType column.
func NewNullTimeColumn(name, typ string) *Column {
return NewTimeColumn(name, typ).
SetNull(true)
}
// NewJSONColumn creates a new JSONType column.
func NewJSONColumn(name, typ string) *Column {
return NewColumn(name).
SetType(&JSONType{T: typ})
}
// NewNullJSONColumn creates a new nullable JSONType column.
func NewNullJSONColumn(name, typ string) *Column {
return NewJSONColumn(name, typ).
SetNull(true)
}
// NewSpatialColumn creates a new SpatialType column.
func NewSpatialColumn(name, typ string) *Column {
return NewColumn(name).
SetType(&SpatialType{T: typ})
}
// NewNullSpatialColumn creates a new nullable SpatialType column.
func NewNullSpatialColumn(name, typ string) *Column {
return NewSpatialColumn(name, typ).
SetNull(true)
}
// SetNull configures the nullability of the column
func (c *Column) SetNull(b bool) *Column {
if c.Type == nil {
c.Type = &ColumnType{}
}
c.Type.Null = b
return c
}
// SetType configures the type of the column
func (c *Column) SetType(t Type) *Column {
if c.Type == nil {
c.Type = &ColumnType{}
}
c.Type.Type = t
return c
}
// SetDefault configures the default of the column
func (c *Column) SetDefault(x Expr) *Column {
c.Default = x
return c
}
// SetCharset sets or appends the Charset attribute
// to the column with the given value.
func (c *Column) SetCharset(v string) *Column {
replaceOrAppend(&c.Attrs, &Charset{V: v})
return c
}
// UnsetCharset unsets the Charset attribute.
func (c *Column) UnsetCharset() *Column {
del(&c.Attrs, &Charset{})
return c
}
// SetCollation sets or appends the Collation attribute
// to the column with the given value.
func (c *Column) SetCollation(v string) *Column {
replaceOrAppend(&c.Attrs, &Collation{V: v})
return c
}
// UnsetCollation the Collation attribute.
func (c *Column) UnsetCollation() *Column {
del(&c.Attrs, &Collation{})
return c
}
// SetComment sets or appends the Comment attribute
// to the column with the given value.
func (c *Column) SetComment(v string) *Column {
replaceOrAppend(&c.Attrs, &Comment{Text: v})
return c
}
// SetGeneratedExpr sets or appends the GeneratedExpr attribute.
func (c *Column) SetGeneratedExpr(x *GeneratedExpr) *Column {
replaceOrAppend(&c.Attrs, x)
return c
}
// AddAttrs adds additional attributes to the column.
func (c *Column) AddAttrs(attrs ...Attr) *Column {
c.Attrs = append(c.Attrs, attrs...)
return c
}
// NewCheck creates a new check.
func NewCheck() *Check {
return &Check{}
}
// SetName configures the name of the check constraint.
func (c *Check) SetName(name string) *Check {
c.Name = name
return c
}
// SetExpr configures the expression of the check constraint.
func (c *Check) SetExpr(expr string) *Check {
c.Expr = expr
return c
}
// AddAttrs adds additional attributes to the check constraint.
func (c *Check) AddAttrs(attrs ...Attr) *Check {
c.Attrs = append(c.Attrs, attrs...)
return c
}
// NewIndex creates a new index with the given name.
func NewIndex(name string) *Index {
return &Index{Name: name}
}
// NewUniqueIndex creates a new unique index with the given name.
func NewUniqueIndex(name string) *Index {
return NewIndex(name).SetUnique(true)
}
// NewPrimaryKey creates a new primary-key index
// for the given columns.
func NewPrimaryKey(columns ...*Column) *Index {
return new(Index).SetUnique(true).AddColumns(columns...)
}
// SetName configures the name of the index.
func (i *Index) SetName(name string) *Index {
i.Name = name
return i
}
// SetUnique configures the uniqueness of the index.
func (i *Index) SetUnique(b bool) *Index {
i.Unique = b
return i
}
// SetTable configures the table of the index.
func (i *Index) SetTable(t *Table) *Index {
i.Table = t
return i
}
// SetComment sets or appends the Comment attribute
// to the index with the given value.
func (i *Index) SetComment(v string) *Index {
replaceOrAppend(&i.Attrs, &Comment{Text: v})
return i
}
// AddAttrs adds additional attributes to the index.
func (i *Index) AddAttrs(attrs ...Attr) *Index {
i.Attrs = append(i.Attrs, attrs...)
return i
}
// AddColumns adds the columns to index parts.
func (i *Index) AddColumns(columns ...*Column) *Index {
for _, c := range columns {
if !c.hasIndex(i) {
c.Indexes = append(c.Indexes, i)
}
i.Parts = append(i.Parts, &IndexPart{SeqNo: len(i.Parts), C: c})
}
return i
}
func (c *Column) hasIndex(idx *Index) bool {
for i := range c.Indexes {
if c.Indexes[i] == idx {
return true
}
}
return false
}
// AddExprs adds the expressions to index parts.
func (i *Index) AddExprs(exprs ...Expr) *Index {
for _, x := range exprs {
i.Parts = append(i.Parts, &IndexPart{SeqNo: len(i.Parts), X: x})
}
return i
}
// AddParts appends the given parts.
func (i *Index) AddParts(parts ...*IndexPart) *Index {
for _, p := range parts {
if p.C != nil && !p.C.hasIndex(i) {
p.C.Indexes = append(p.C.Indexes, i)
}
p.SeqNo = len(i.Parts)
i.Parts = append(i.Parts, p)
}
return i
}
// NewIndexPart creates a new index part.
func NewIndexPart() *IndexPart { return &IndexPart{} }
// NewColumnPart creates a new index part with the given column.
func NewColumnPart(c *Column) *IndexPart { return &IndexPart{C: c} }
// NewExprPart creates a new index part with the given expression.
func NewExprPart(x Expr) *IndexPart { return &IndexPart{X: x} }
// SetDesc configures the "DESC" attribute of the key part.
func (p *IndexPart) SetDesc(b bool) *IndexPart {
p.Desc = b
return p
}
// AddAttrs adds and additional attributes to the index-part.
func (p *IndexPart) AddAttrs(attrs ...Attr) *IndexPart {
p.Attrs = append(p.Attrs, attrs...)
return p
}
// SetColumn sets the column of the index-part.
func (p *IndexPart) SetColumn(c *Column) *IndexPart {
p.C = c
return p
}
// SetExpr sets the expression of the index-part.
func (p *IndexPart) SetExpr(x Expr) *IndexPart {
p.X = x
return p
}
// NewForeignKey creates a new foreign-key with
// the given constraints/symbol name.
func NewForeignKey(symbol string) *ForeignKey {
return &ForeignKey{Symbol: symbol}
}
// SetTable configures the table that holds the foreign-key (child table).
func (f *ForeignKey) SetTable(t *Table) *ForeignKey {
f.Table = t
return f
}
// AddColumns appends columns to the child-table columns.
func (f *ForeignKey) AddColumns(columns ...*Column) *ForeignKey {
for _, c := range columns {
if !c.hasForeignKey(f) {
c.ForeignKeys = append(c.ForeignKeys, f)
}
}
f.Columns = append(f.Columns, columns...)
return f
}
func (c *Column) hasForeignKey(fk *ForeignKey) bool {
for i := range c.ForeignKeys {
if c.ForeignKeys[i] == fk {
return true
}
}
return false
}
// SetRefTable configures the referenced/parent table.
func (f *ForeignKey) SetRefTable(t *Table) *ForeignKey {
f.RefTable = t
return f
}
// AddRefColumns appends columns to the parent-table columns.
func (f *ForeignKey) AddRefColumns(columns ...*Column) *ForeignKey {
f.RefColumns = append(f.RefColumns, columns...)
return f
}
// SetOnUpdate sets the ON UPDATE constraint action.
func (f *ForeignKey) SetOnUpdate(o ReferenceOption) *ForeignKey {
f.OnUpdate = o
return f
}
// SetOnDelete sets the ON DELETE constraint action.
func (f *ForeignKey) SetOnDelete(o ReferenceOption) *ForeignKey {
f.OnDelete = o
return f
}
// replaceOrAppend searches an attribute of the same type as v in
// the list and replaces it. Otherwise, v is appended to the list.
func replaceOrAppend(attrs *[]Attr, v Attr) {
t := reflect.TypeOf(v)
for i := range *attrs {
if reflect.TypeOf((*attrs)[i]) == t {
(*attrs)[i] = v
return
}
}
*attrs = append(*attrs, v)
}
// ReplaceOrAppend searches an attribute of the same type as v in
// the list and replaces it. Otherwise, v is appended to the list.
func ReplaceOrAppend(attrs *[]Attr, v Attr) {
replaceOrAppend(attrs, v)
}
// del searches an attribute of the same type as v in
// the list and delete it.
func del(attrs *[]Attr, v Attr) {
t := reflect.TypeOf(v)
for i := range *attrs {
if reflect.TypeOf((*attrs)[i]) == t {
*attrs = append((*attrs)[:i], (*attrs)[i+1:]...)
return
}
}
}
atlas-0.7.2/sql/schema/dsl_test.go 0000664 0000000 0000000 00000014573 14314555116 0017052 0 ustar 00root root 0000000 0000000 // Copyright 2021-present The Atlas Authors. All rights reserved.
// This source code is licensed under the Apache 2.0 license found
// in the LICENSE file in the root directory of this source tree.
package schema_test
import (
"testing"
"ariga.io/atlas/sql/schema"
"github.com/stretchr/testify/require"
)
func TestTable_AddColumns(t *testing.T) {
users := schema.NewTable("users").
SetComment("users table").
AddColumns(
schema.NewBoolColumn("active", "bool"),
schema.NewDecimalColumn("age", "decimal"),
schema.NewNullStringColumn("name", "varchar", schema.StringSize(255)),
)
require.Equal(
t,
&schema.Table{
Name: "users",
Attrs: []schema.Attr{
&schema.Comment{Text: "users table"},
},
Columns: []*schema.Column{
{Name: "active", Type: &schema.ColumnType{Type: &schema.BoolType{T: "bool"}}},
{Name: "age", Type: &schema.ColumnType{Type: &schema.DecimalType{T: "decimal"}}},
{Name: "name", Type: &schema.ColumnType{Null: true, Type: &schema.StringType{T: "varchar", Size: 255}}},
},
},
users,
)
}
func TestSchema_AddTables(t *testing.T) {
userColumns := []*schema.Column{
schema.NewIntColumn("id", "int"),
schema.NewBoolColumn("active", "boolean"),
schema.NewNullStringColumn("name", "varchar", schema.StringSize(255)),
schema.NewTimeColumn("registered_at", "timestamp", schema.TimePrecision(6)),
}
users := schema.NewTable("users").
AddColumns(userColumns...).
SetPrimaryKey(schema.NewPrimaryKey(userColumns[0])).
SetComment("users table").
AddIndexes(
schema.NewUniqueIndex("unique_name").
AddColumns(userColumns[2]).
SetComment("index comment"),
)
postColumns := []*schema.Column{
schema.NewIntColumn("id", "int"),
schema.NewStringColumn("text", "longtext"),
schema.NewNullIntColumn("author_id", "int"),
}
posts := schema.NewTable("posts").
AddColumns(postColumns...).
SetPrimaryKey(schema.NewPrimaryKey(postColumns[0])).
SetComment("posts table").
AddForeignKeys(
schema.NewForeignKey("author_id").
AddColumns(postColumns[2]).
SetRefTable(users).
AddRefColumns(userColumns[0]).
SetOnDelete(schema.Cascade).
SetOnUpdate(schema.SetNull),
)
require.Equal(
t,
func() *schema.Schema {
p := 6
s := &schema.Schema{Name: "public"}
users := &schema.Table{
Name: "users",
Schema: s,
Attrs: []schema.Attr{
&schema.Comment{Text: "users table"},
},
Columns: []*schema.Column{
{Name: "id", Type: &schema.ColumnType{Type: &schema.IntegerType{T: "int"}}},
{Name: "active", Type: &schema.ColumnType{Type: &schema.BoolType{T: "boolean"}}},
{Name: "name", Type: &schema.ColumnType{Null: true, Type: &schema.StringType{T: "varchar", Size: 255}}},
{Name: "registered_at", Type: &schema.ColumnType{Null: false, Type: &schema.TimeType{T: "timestamp", Precision: &p}}},
},
}
s.Tables = append(s.Tables, users)
users.PrimaryKey = &schema.Index{Unique: true, Parts: []*schema.IndexPart{{C: users.Columns[0]}}}
users.PrimaryKey.Table = users
users.Columns[0].Indexes = append(users.Columns[0].Indexes, users.PrimaryKey)
users.Indexes = append(users.Indexes, &schema.Index{
Name: "unique_name",
Unique: true,
Parts: []*schema.IndexPart{{C: users.Columns[2]}},
Attrs: []schema.Attr{&schema.Comment{Text: "index comment"}},
})
users.Indexes[0].Table = users
users.Columns[2].Indexes = users.Indexes
posts := &schema.Table{
Name: "posts",
Schema: s,
Attrs: []schema.Attr{
&schema.Comment{Text: "posts table"},
},
Columns: []*schema.Column{
{Name: "id", Type: &schema.ColumnType{Type: &schema.IntegerType{T: "int"}}},
{Name: "text", Type: &schema.ColumnType{Type: &schema.StringType{T: "longtext"}}},
{Name: "author_id", Type: &schema.ColumnType{Null: true, Type: &schema.IntegerType{T: "int"}}},
},
}
s.Tables = append(s.Tables, posts)
posts.PrimaryKey = &schema.Index{Unique: true, Parts: []*schema.IndexPart{{C: posts.Columns[0]}}}
posts.PrimaryKey.Table = posts
posts.Columns[0].Indexes = append(posts.Columns[0].Indexes, posts.PrimaryKey)
posts.ForeignKeys = append(posts.ForeignKeys, &schema.ForeignKey{
Symbol: "author_id",
Table: posts,
Columns: posts.Columns[2:],
RefTable: users,
RefColumns: users.Columns[0:1],
OnDelete: schema.Cascade,
OnUpdate: schema.SetNull,
})
posts.Columns[2].ForeignKeys = posts.ForeignKeys
return s
}(),
schema.New("public").AddTables(users, posts),
)
}
func TestSchema_SetCharset(t *testing.T) {
s := schema.New("public")
require.Empty(t, s.Attrs)
s.SetCharset("utf8mb4")
require.Len(t, s.Attrs, 1)
require.Equal(t, &schema.Charset{V: "utf8mb4"}, s.Attrs[0])
s.SetCharset("latin1")
require.Len(t, s.Attrs, 1)
require.Equal(t, &schema.Charset{V: "latin1"}, s.Attrs[0])
s.UnsetCharset()
require.Empty(t, s.Attrs)
}
func TestSchema_SetCollation(t *testing.T) {
s := schema.New("public")
require.Empty(t, s.Attrs)
s.SetCollation("utf8mb4_general_ci")
require.Len(t, s.Attrs, 1)
require.Equal(t, &schema.Collation{V: "utf8mb4_general_ci"}, s.Attrs[0])
s.SetCollation("latin1_swedish_ci")
require.Len(t, s.Attrs, 1)
require.Equal(t, &schema.Collation{V: "latin1_swedish_ci"}, s.Attrs[0])
s.UnsetCollation()
require.Empty(t, s.Attrs)
}
func TestSchema_SetComment(t *testing.T) {
s := schema.New("public")
require.Empty(t, s.Attrs)
s.SetComment("1")
require.Len(t, s.Attrs, 1)
require.Equal(t, &schema.Comment{Text: "1"}, s.Attrs[0])
s.SetComment("2")
require.Len(t, s.Attrs, 1)
require.Equal(t, &schema.Comment{Text: "2"}, s.Attrs[0])
}
func TestSchema_SetGeneratedExpr(t *testing.T) {
c := schema.NewIntColumn("c", "int")
require.Empty(t, c.Attrs)
x := &schema.GeneratedExpr{Expr: "d*2", Type: "VIRTUAL"}
c.SetGeneratedExpr(x)
require.Equal(t, []schema.Attr{x}, c.Attrs)
}
func TestCheck(t *testing.T) {
enforced := &struct{ schema.Attr }{}
tbl := schema.NewTable("table").
AddColumns(
schema.NewColumn("price1"),
schema.NewColumn("price2"),
)
require.Empty(t, tbl.Attrs)
tbl.AddChecks(
schema.NewCheck().
SetName("unique prices").
SetExpr("price1 <> price2"),
schema.NewCheck().
SetExpr("price1 > 0").
AddAttrs(enforced),
)
require.Len(t, tbl.Attrs, 2)
require.Equal(t, &schema.Check{
Name: "unique prices",
Expr: "price1 <> price2",
}, tbl.Attrs[0])
require.Equal(t, &schema.Check{
Expr: "price1 > 0",
Attrs: []schema.Attr{enforced},
}, tbl.Attrs[1])
}
atlas-0.7.2/sql/schema/inspect.go 0000664 0000000 0000000 00000011046 14314555116 0016666 0 ustar 00root root 0000000 0000000 // Copyright 2021-present The Atlas Authors. All rights reserved.
// This source code is licensed under the Apache 2.0 license found
// in the LICENSE file in the root directory of this source tree.
package schema
import (
"context"
"database/sql"
"errors"
)
// A NotExistError wraps another error to retain its original text
// but makes it possible to the migrator to catch it.
type NotExistError struct {
Err error
}
func (e NotExistError) Error() string { return e.Err.Error() }
// IsNotExistError reports if an error is a NotExistError.
func IsNotExistError(err error) bool {
if err == nil {
return false
}
var e *NotExistError
return errors.As(err, &e)
}
// ExecQuerier wraps the two standard sql.DB methods.
type ExecQuerier interface {
QueryContext(ctx context.Context, query string, args ...any) (*sql.Rows, error)
ExecContext(ctx context.Context, query string, args ...any) (sql.Result, error)
}
// An InspectMode controls the amount and depth of information returned on inspection.
type InspectMode uint
const (
// InspectSchemas enables schema inspection.
InspectSchemas InspectMode = 1 << iota
// InspectTables enables schema tables inspection including
// all its child resources (e.g. columns or indexes).
InspectTables
)
// Is reports whether the given mode is enabled.
func (m InspectMode) Is(i InspectMode) bool { return m&i != 0 }
type (
// InspectOptions describes options for Inspector.
InspectOptions struct {
// Mode defines the amount of information returned by InspectSchema.
// If zero, InspectSchema inspects whole resources in the schema.
Mode InspectMode
// Tables to inspect. Empty means all tables in the schema.
Tables []string
// Exclude defines a list of glob patterns used to filter resources from inspection.
// The syntax used by the different drivers is implemented as follows:
//
// t // exclude table 't'.
// * // exclude all tables.
// t.c // exclude column, index and foreign-key named 'c' in table 't'.
// t.* // the last item defines the filtering; all resources under 't' are excluded.
// *.c // the last item defines the filtering; all resourced named 'c' are excluded in all tables.
// *.* // the last item defines the filtering; all resourced under all tables are excluded.
//
Exclude []string
}
// InspectRealmOption describes options for RealmInspector.
InspectRealmOption struct {
// Mode defines the amount of information returned by InspectRealm.
// If zero, InspectRealm inspects all schemas and their child resources.
Mode InspectMode
// Schemas to inspect. Empty means all schemas in the realm.
Schemas []string
// Exclude defines a list of glob patterns used to filter resources from inspection.
// The syntax used by the different drivers is implemented as follows:
//
// s // exclude schema 't'.
// * // exclude all schemas.
// s.t // exclude table 't' under schema 's'.
// s.* // the last item defines the filtering; all tables under 's' are excluded.
// *.t // the last item defines the filtering; all tables named 't' are excluded in all schemas.
// *.* // the last item defines the filtering; all tables under all schemas are excluded.
// *.*.c // the last item defines the filtering; all resourced named 'c' are excluded in all tables.
// *.*.* // the last item defines the filtering; all resources are excluded in all tables.
//
Exclude []string
}
// Inspector is the interface implemented by the different database
// drivers for inspecting schema or databases.
Inspector interface {
// InspectSchema returns the schema description by its name. An empty name means the
// "attached schema" (e.g. SCHEMA() in MySQL or CURRENT_SCHEMA() in PostgreSQL).
// A NotExistError error is returned if the schema does not exist in the database.
InspectSchema(ctx context.Context, name string, opts *InspectOptions) (*Schema, error)
// InspectRealm returns the description of the connected database.
InspectRealm(ctx context.Context, opts *InspectRealmOption) (*Realm, error)
}
)
// Normalizer is the interface implemented by the different database drivers for
// "normalizing" schema objects. i.e. converting schema objects defined in natural
// form to their representation in the database. Thus, two schema objects are equal
// if their normal forms are equal.
type Normalizer interface {
// NormalizeSchema returns the normal representation of a schema.
NormalizeSchema(context.Context, *Schema) (*Schema, error)
// NormalizeRealm returns the normal representation of a database.
NormalizeRealm(context.Context, *Realm) (*Realm, error)
}
atlas-0.7.2/sql/schema/migrate.go 0000664 0000000 0000000 00000025507 14314555116 0016660 0 ustar 00root root 0000000 0000000 // Copyright 2021-present The Atlas Authors. All rights reserved.
// This source code is licensed under the Apache 2.0 license found
// in the LICENSE file in the root directory of this source tree.
package schema
import (
"context"
"errors"
"time"
)
type (
// A Change represents a schema change. The types below implement this
// interface and can be used for describing schema changes.
//
// The Change interface can also be implemented outside this package
// as follows:
//
// type RenameType struct {
// schema.Change
// From, To string
// }
//
// var t schema.Change = &RenameType{From: "old", To: "new"}
//
Change interface {
change()
}
// Clause carries additional information that can be added
// to schema changes. The Clause interface can be implemented
// outside this package as follows:
//
// type Authorization struct {
// schema.Clause
// UserName string
// }
//
// var c schema.Clause = &Authorization{UserName: "a8m"}
//
Clause interface {
clause()
}
// AddSchema describes a schema (named database) creation change.
// Unlike table creation, schemas and their elements are described
// with separate changes. For example, "AddSchema" and "AddTable"
AddSchema struct {
S *Schema
Extra []Clause // Extra clauses and options.
}
// DropSchema describes a schema (named database) removal change.
DropSchema struct {
S *Schema
Extra []Clause // Extra clauses and options.
}
// ModifySchema describes a modification change for schema attributes.
ModifySchema struct {
S *Schema
Changes []Change
}
// AddTable describes a table creation change.
AddTable struct {
T *Table
Extra []Clause // Extra clauses and options.
}
// DropTable describes a table removal change.
DropTable struct {
T *Table
Extra []Clause // Extra clauses.
}
// ModifyTable describes a table modification change.
ModifyTable struct {
T *Table
Changes []Change
}
// RenameTable describes a table rename change.
RenameTable struct {
From, To *Table
}
// AddColumn describes a column creation change.
AddColumn struct {
C *Column
}
// DropColumn describes a column removal change.
DropColumn struct {
C *Column
}
// ModifyColumn describes a change that modifies a column.
ModifyColumn struct {
From, To *Column
Change ChangeKind
}
// RenameColumn describes a column rename change.
RenameColumn struct {
From, To *Column
}
// AddIndex describes an index creation change.
AddIndex struct {
I *Index
}
// DropIndex describes an index removal change.
DropIndex struct {
I *Index
}
// ModifyIndex describes an index modification.
ModifyIndex struct {
From, To *Index
Change ChangeKind
}
// RenameIndex describes an index rename change.
RenameIndex struct {
From, To *Index
}
// AddForeignKey describes a foreign-key creation change.
AddForeignKey struct {
F *ForeignKey
}
// DropForeignKey describes a foreign-key removal change.
DropForeignKey struct {
F *ForeignKey
}
// ModifyForeignKey describes a change that modifies a foreign-key.
ModifyForeignKey struct {
From, To *ForeignKey
Change ChangeKind
}
// AddCheck describes a CHECK constraint creation change.
AddCheck struct {
C *Check
}
// DropCheck describes a CHECK constraint removal change.
DropCheck struct {
C *Check
}
// ModifyCheck describes a change that modifies a check.
ModifyCheck struct {
From, To *Check
Change ChangeKind
}
// AddAttr describes an attribute addition.
AddAttr struct {
A Attr
}
// DropAttr describes an attribute removal.
DropAttr struct {
A Attr
}
// ModifyAttr describes a change that modifies an element attribute.
ModifyAttr struct {
From, To Attr
}
// IfExists represents a clause in a schema change that is commonly
// supported by multiple statements (e.g. DROP TABLE or DROP SCHEMA).
IfExists struct{}
// IfNotExists represents a clause in a schema change that is commonly
// supported by multiple statements (e.g. CREATE TABLE or CREATE SCHEMA).
IfNotExists struct{}
)
// A ChangeKind describes a change kind that can be combined
// using a set of flags. The zero kind is no change.
type ChangeKind uint
const (
// NoChange holds the zero value of a change kind.
NoChange ChangeKind = 0
// Common changes.
// ChangeAttr describes attributes change of an element.
// For example, a table CHECK was added or changed.
ChangeAttr ChangeKind = 1 << (iota - 1)
// ChangeCharset describes character-set change.
ChangeCharset
// ChangeCollate describes collation/encoding change.
ChangeCollate
// ChangeComment describes comment chang (of any element).
ChangeComment
// Column specific changes.
// ChangeNull describe a change to the NULL constraint.
ChangeNull
// ChangeType describe a column type change.
ChangeType
// ChangeDefault describe a column default change.
ChangeDefault
// ChangeGenerated describe a change to the generated expression.
ChangeGenerated
// Index specific changes.
// ChangeUnique describes a change to the uniqueness constraint.
// For example, an index was changed from non-unique to unique.
ChangeUnique
// ChangeParts describes a change to one or more of the index parts.
// For example, index keeps its previous name, but the columns order
// was changed.
ChangeParts
// Foreign key specific changes.
// ChangeColumn describes a change to the foreign-key (child) columns.
ChangeColumn
// ChangeRefColumn describes a change to the foreign-key (parent) columns.
ChangeRefColumn
// ChangeRefTable describes a change to the foreign-key (parent) table.
ChangeRefTable
// ChangeUpdateAction describes a change to the foreign-key update action.
ChangeUpdateAction
// ChangeDeleteAction describes a change to the foreign-key delete action.
ChangeDeleteAction
)
// Is reports whether c is match the given change kind.
func (k ChangeKind) Is(c ChangeKind) bool {
return k == c || k&c != 0
}
// Differ is the interface implemented by the different
// drivers for comparing and diffing schema top elements.
type Differ interface {
// RealmDiff returns a diff report for migrating a realm
// (or a database) from state "from" to state "to". An error
// is returned if such step is not possible.
RealmDiff(from, to *Realm) ([]Change, error)
// SchemaDiff returns a diff report for migrating a schema
// from state "from" to state "to". An error is returned
// if such step is not possible.
SchemaDiff(from, to *Schema) ([]Change, error)
// TableDiff returns a diff report for migrating a table
// from state "from" to state "to". An error is returned
// if such step is not possible.
TableDiff(from, to *Table) ([]Change, error)
}
// ErrLocked is returned on Lock calls which have failed to obtain the lock.
var ErrLocked = errors.New("sql/schema: lock is held by other session")
type (
// UnlockFunc is returned by the Locker to explicitly
// release the named "advisory lock".
UnlockFunc func() error
// Locker is an interface that is optionally implemented by the different drivers
// for obtaining an "advisory lock" with the given name.
Locker interface {
// Lock acquires a named "advisory lock", using the given timeout. Negative value means no timeout,
// and the zero value means a "try lock" mode. i.e. return immediately if the lock is already taken.
// The returned unlock function is used to release the advisory lock acquired by the session.
//
// An ErrLocked is returned if the operation failed to obtain the lock in all different timeout modes.
Lock(ctx context.Context, name string, timeout time.Duration) (UnlockFunc, error)
}
)
// Changes is a list of changes allow for searching and mutating changes.
type Changes []Change
// IndexAddTable returns the index of the first AddTable in the changes with
// the given name, or -1 if there is no such change in the Changes.
func (c Changes) IndexAddTable(name string) int {
return c.search(func(c Change) bool {
a, ok := c.(*AddTable)
return ok && a.T.Name == name
})
}
// IndexDropTable returns the index of the first DropTable in the changes with
// the given name, or -1 if there is no such change in the Changes.
func (c Changes) IndexDropTable(name string) int {
return c.search(func(c Change) bool {
a, ok := c.(*DropTable)
return ok && a.T.Name == name
})
}
// IndexAddColumn returns the index of the first AddColumn in the changes with
// the given name, or -1 if there is no such change in the Changes.
func (c Changes) IndexAddColumn(name string) int {
return c.search(func(c Change) bool {
a, ok := c.(*AddColumn)
return ok && a.C.Name == name
})
}
// IndexDropColumn returns the index of the first DropColumn in the changes with
// the given name, or -1 if there is no such change in the Changes.
func (c Changes) IndexDropColumn(name string) int {
return c.search(func(c Change) bool {
d, ok := c.(*DropColumn)
return ok && d.C.Name == name
})
}
// IndexAddIndex returns the index of the first AddIndex in the changes with
// the given name, or -1 if there is no such change in the Changes.
func (c Changes) IndexAddIndex(name string) int {
return c.search(func(c Change) bool {
a, ok := c.(*AddIndex)
return ok && a.I.Name == name
})
}
// IndexDropIndex returns the index of the first DropIndex in the changes with
// the given name, or -1 if there is no such change in the Changes.
func (c Changes) IndexDropIndex(name string) int {
return c.search(func(c Change) bool {
a, ok := c.(*DropIndex)
return ok && a.I.Name == name
})
}
// RemoveIndex removes elements in the given indexes from the Changes.
func (c *Changes) RemoveIndex(indexes ...int) {
changes := make([]Change, 0, len(*c)-len(indexes))
Loop:
for i := range *c {
for _, idx := range indexes {
if i == idx {
continue Loop
}
}
changes = append(changes, (*c)[i])
}
*c = changes
}
// search returns the index of the first call to f that returns true, or -1.
func (c Changes) search(f func(Change) bool) int {
for i := range c {
if f(c[i]) {
return i
}
}
return -1
}
// changes.
func (*AddAttr) change() {}
func (*DropAttr) change() {}
func (*ModifyAttr) change() {}
func (*AddSchema) change() {}
func (*DropSchema) change() {}
func (*ModifySchema) change() {}
func (*AddTable) change() {}
func (*DropTable) change() {}
func (*ModifyTable) change() {}
func (*RenameTable) change() {}
func (*AddIndex) change() {}
func (*DropIndex) change() {}
func (*ModifyIndex) change() {}
func (*RenameIndex) change() {}
func (*AddCheck) change() {}
func (*DropCheck) change() {}
func (*ModifyCheck) change() {}
func (*AddColumn) change() {}
func (*DropColumn) change() {}
func (*ModifyColumn) change() {}
func (*RenameColumn) change() {}
func (*AddForeignKey) change() {}
func (*DropForeignKey) change() {}
func (*ModifyForeignKey) change() {}
// clauses.
func (*IfExists) clause() {}
func (*IfNotExists) clause() {}
atlas-0.7.2/sql/schema/migrate_test.go 0000664 0000000 0000000 00000010005 14314555116 0017702 0 ustar 00root root 0000000 0000000 // Copyright 2021-present The Atlas Authors. All rights reserved.
// This source code is licensed under the Apache 2.0 license found
// in the LICENSE file in the root directory of this source tree.
package schema_test
import (
"fmt"
"log"
"strconv"
"testing"
"ariga.io/atlas/sql/schema"
"github.com/stretchr/testify/require"
)
func TestChanges_IndexAddTable(t *testing.T) {
changes := schema.Changes{
&schema.AddTable{T: schema.NewTable("users")},
&schema.DropTable{T: schema.NewTable("posts")},
&schema.AddTable{T: schema.NewTable("posts")},
&schema.AddTable{T: schema.NewTable("posts")},
}
require.Equal(t, 2, changes.IndexAddTable("posts"))
require.Equal(t, -1, changes.IndexAddTable("post_tags"))
}
func TestChanges_IndexDropTable(t *testing.T) {
changes := schema.Changes{
&schema.DropTable{T: schema.NewTable("users")},
&schema.AddTable{T: schema.NewTable("posts")},
&schema.DropTable{T: schema.NewTable("posts")},
}
require.Equal(t, 2, changes.IndexDropTable("posts"))
require.Equal(t, -1, changes.IndexDropTable("post_tags"))
}
func TestChanges_IndexAddColumn(t *testing.T) {
changes := schema.Changes{
&schema.AddColumn{C: schema.NewColumn("name")},
&schema.DropColumn{C: schema.NewColumn("name")},
&schema.AddColumn{C: schema.NewColumn("name")},
}
require.Equal(t, 0, changes.IndexAddColumn("name"))
require.Equal(t, -1, changes.IndexAddColumn("created_at"))
}
func TestChanges_IndexDropColumn(t *testing.T) {
changes := schema.Changes{
&schema.AddColumn{C: schema.NewColumn("name")},
&schema.DropColumn{C: schema.NewColumn("name")},
&schema.AddColumn{C: schema.NewColumn("name")},
}
require.Equal(t, 1, changes.IndexDropColumn("name"))
require.Equal(t, -1, changes.IndexDropColumn("created_at"))
}
func TestChanges_IndexAddIndex(t *testing.T) {
changes := schema.Changes{
&schema.DropIndex{I: schema.NewIndex("name")},
&schema.AddIndex{I: schema.NewIndex("created_at")},
&schema.AddIndex{I: schema.NewIndex("name")},
}
require.Equal(t, 2, changes.IndexAddIndex("name"))
require.Equal(t, -1, changes.IndexAddIndex("age"))
}
func TestChanges_IndexDropIndex(t *testing.T) {
changes := schema.Changes{
&schema.AddIndex{I: schema.NewIndex("name")},
&schema.DropIndex{I: schema.NewIndex("created_at")},
&schema.DropIndex{I: schema.NewIndex("name")},
}
require.Equal(t, 2, changes.IndexDropIndex("name"))
require.Equal(t, -1, changes.IndexDropIndex("age"))
}
func TestChanges_RemoveIndex(t *testing.T) {
changes := make(schema.Changes, 0, 5)
for i := 0; i < 5; i++ {
changes = append(changes, &schema.AddColumn{C: schema.NewColumn(strconv.Itoa(i))})
}
changes.RemoveIndex(0)
require.Equal(t, 4, len(changes))
for i := 0; i < 4; i++ {
require.Equal(t, strconv.Itoa(i+1), changes[i].(*schema.AddColumn).C.Name)
}
changes.RemoveIndex(0, 3, 2)
require.Equal(t, 1, len(changes))
require.Equal(t, "2", changes[0].(*schema.AddColumn).C.Name)
}
func ExampleChanges_Replace() {
changes := schema.Changes{
&schema.AddIndex{I: schema.NewIndex("id")},
&schema.AddColumn{C: schema.NewColumn("new_name")},
&schema.AddColumn{C: schema.NewColumn("id")},
&schema.AddColumn{C: schema.NewColumn("created_at")},
&schema.DropColumn{C: schema.NewColumn("old_name")},
}
i, j := changes.IndexAddColumn("new_name"), changes.IndexDropColumn("old_name")
if i == -1 || j == -1 {
log.Fatalln("Unexpected change positions")
}
// Replace "add" and "drop" with "rename".
changes = append(changes, &schema.RenameColumn{From: changes[j].(*schema.DropColumn).C, To: changes[i].(*schema.AddColumn).C})
changes.RemoveIndex(i, j)
for _, c := range changes {
switch c := c.(type) {
case *schema.AddColumn:
fmt.Printf("%T(%s)\n", c, c.C.Name)
case *schema.DropColumn:
fmt.Printf("%T(%s)\n", c, c.C.Name)
case *schema.RenameColumn:
fmt.Printf("%T(%s -> %s)\n", c, c.From.Name, c.To.Name)
case *schema.AddIndex:
fmt.Printf("%T(%s)\n", c, c.I.Name)
}
}
// Output:
// *schema.AddIndex(id)
// *schema.AddColumn(id)
// *schema.AddColumn(created_at)
// *schema.RenameColumn(old_name -> new_name)
}
atlas-0.7.2/sql/schema/schema.go 0000664 0000000 0000000 00000016614 14314555116 0016467 0 ustar 00root root 0000000 0000000 // Copyright 2021-present The Atlas Authors. All rights reserved.
// This source code is licensed under the Apache 2.0 license found
// in the LICENSE file in the root directory of this source tree.
package schema
type (
// A Realm or a database describes a domain of schema resources that are logically connected
// and can be accessed and queried in the same connection (e.g. a physical database instance).
Realm struct {
Schemas []*Schema
Attrs []Attr
}
// A Schema describes a database schema (i.e. named database).
Schema struct {
Name string
Realm *Realm
Tables []*Table
Attrs []Attr // Attrs and options.
}
// A Table represents a table definition.
Table struct {
Name string
Schema *Schema
Columns []*Column
Indexes []*Index
PrimaryKey *Index
ForeignKeys []*ForeignKey
Attrs []Attr // Attrs, constraints and options.
}
// A Column represents a column definition.
Column struct {
Name string
Type *ColumnType
Default Expr
Attrs []Attr
Indexes []*Index
// Foreign keys that this column is
// part of their child columns.
ForeignKeys []*ForeignKey
}
// ColumnType represents a column type that is implemented by the dialect.
ColumnType struct {
Type Type
Raw string
Null bool
}
// An Index represents an index definition.
Index struct {
Name string
Unique bool
Table *Table
Attrs []Attr
Parts []*IndexPart
}
// An IndexPart represents an index part that
// can be either an expression or a column.
IndexPart struct {
// SeqNo represents the sequence number of the key part
// in the index.
SeqNo int
// Desc indicates if the key part is stored in descending
// order. All databases use ascending order as default.
Desc bool
X Expr
C *Column
Attrs []Attr
}
// A ForeignKey represents an index definition.
ForeignKey struct {
Symbol string
Table *Table
Columns []*Column
RefTable *Table
RefColumns []*Column
OnUpdate ReferenceOption
OnDelete ReferenceOption
}
)
// Schema returns the first schema that matched the given name.
func (r *Realm) Schema(name string) (*Schema, bool) {
for _, s := range r.Schemas {
if s.Name == name {
return s, true
}
}
return nil, false
}
// Table returns the first table that matched the given name.
func (s *Schema) Table(name string) (*Table, bool) {
for _, t := range s.Tables {
if t.Name == name {
return t, true
}
}
return nil, false
}
// Column returns the first column that matched the given name.
func (t *Table) Column(name string) (*Column, bool) {
for _, c := range t.Columns {
if c.Name == name {
return c, true
}
}
return nil, false
}
// Index returns the first index that matched the given name.
func (t *Table) Index(name string) (*Index, bool) {
for _, i := range t.Indexes {
if i.Name == name {
return i, true
}
}
return nil, false
}
// ForeignKey returns the first foreign-key that matched the given symbol (constraint name).
func (t *Table) ForeignKey(symbol string) (*ForeignKey, bool) {
for _, f := range t.ForeignKeys {
if f.Symbol == symbol {
return f, true
}
}
return nil, false
}
// Column returns the first column that matches the given name.
func (f *ForeignKey) Column(name string) (*Column, bool) {
for _, c := range f.Columns {
if c.Name == name {
return c, true
}
}
return nil, false
}
// RefColumn returns the first referenced column that matches the given name.
func (f *ForeignKey) RefColumn(name string) (*Column, bool) {
for _, c := range f.RefColumns {
if c.Name == name {
return c, true
}
}
return nil, false
}
// ReferenceOption for constraint actions.
type ReferenceOption string
// Reference options (actions) specified by ON UPDATE and ON DELETE
// subclauses of the FOREIGN KEY clause.
const (
NoAction ReferenceOption = "NO ACTION"
Restrict ReferenceOption = "RESTRICT"
Cascade ReferenceOption = "CASCADE"
SetNull ReferenceOption = "SET NULL"
SetDefault ReferenceOption = "SET DEFAULT"
)
type (
// A Type represents a database type. The types below implements this
// interface and can be used for describing schemas.
//
// The Type interface can also be implemented outside this package as follows:
//
// type SpatialType struct {
// schema.Type
// T string
// }
//
// var t schema.Type = &SpatialType{T: "point"}
//
Type interface {
typ()
}
// EnumType represents an enum type.
EnumType struct {
T string // Optional type.
Values []string // Enum values.
Schema *Schema // Optional schema.
}
// BinaryType represents a type that stores a binary data.
BinaryType struct {
T string
Size *int
}
// StringType represents a string type.
StringType struct {
T string
Size int
}
// BoolType represents a boolean type.
BoolType struct {
T string
}
// IntegerType represents an int type.
IntegerType struct {
T string
Unsigned bool
Attrs []Attr
}
// DecimalType represents a fixed-point type that stores exact numeric values.
DecimalType struct {
T string
Precision int
Scale int
Unsigned bool
}
// FloatType represents a floating-point type that stores approximate numeric values.
FloatType struct {
T string
Unsigned bool
Precision int
}
// TimeType represents a date/time type.
TimeType struct {
T string
Precision *int
}
// JSONType represents a JSON type.
JSONType struct {
T string
}
// SpatialType represents a spatial/geometric type.
SpatialType struct {
T string
}
// UnsupportedType represents a type that is not supported by the drivers.
UnsupportedType struct {
T string
}
)
type (
// Expr defines an SQL expression in schema DDL.
Expr interface {
expr()
}
// Literal represents a basic literal expression like 1, or '1'.
// String literals are usually quoted with single or double quotes.
Literal struct {
V string
}
// RawExpr represents a raw expression like "uuid()" or "current_timestamp()".
// Unlike literals, raw expression are usually inlined as is on migration.
RawExpr struct {
X string
}
)
type (
// Attr represents the interface that all attributes implement.
Attr interface {
attr()
}
// Comment describes a schema element comment.
Comment struct {
Text string
}
// Charset describes a column or a table character-set setting.
Charset struct {
V string
}
// Collation describes a column or a table collation setting.
Collation struct {
V string
}
// Check describes a CHECK constraint.
Check struct {
Name string // Optional constraint name.
Expr string // Actual CHECK.
Attrs []Attr // Additional attributes (e.g. ENFORCED).
}
// GeneratedExpr describes the expression used for generating
// the value of a generated/virtual column.
GeneratedExpr struct {
Expr string
Type string // Optional type. e.g. STORED or VIRTUAL.
}
)
// expressions.
func (*Literal) expr() {}
func (*RawExpr) expr() {}
// types.
func (*BoolType) typ() {}
func (*EnumType) typ() {}
func (*TimeType) typ() {}
func (*JSONType) typ() {}
func (*FloatType) typ() {}
func (*StringType) typ() {}
func (*BinaryType) typ() {}
func (*SpatialType) typ() {}
func (*IntegerType) typ() {}
func (*DecimalType) typ() {}
func (*UnsupportedType) typ() {}
// attributes.
func (*Check) attr() {}
func (*Comment) attr() {}
func (*Charset) attr() {}
func (*Collation) attr() {}
func (*GeneratedExpr) attr() {}
atlas-0.7.2/sql/sqlcheck/ 0000775 0000000 0000000 00000000000 14314555116 0015225 5 ustar 00root root 0000000 0000000 atlas-0.7.2/sql/sqlcheck/datadepend/ 0000775 0000000 0000000 00000000000 14314555116 0017316 5 ustar 00root root 0000000 0000000 atlas-0.7.2/sql/sqlcheck/datadepend/datadepend.go 0000664 0000000 0000000 00000014221 14314555116 0021736 0 ustar 00root root 0000000 0000000 // Copyright 2021-present The Atlas Authors. All rights reserved.
// This source code is licensed under the Apache 2.0 license found
// in the LICENSE file in the root directory of this source tree.
package datadepend
import (
"context"
"errors"
"fmt"
"ariga.io/atlas/schemahcl"
"ariga.io/atlas/sql/internal/sqlx"
"ariga.io/atlas/sql/migrate"
"ariga.io/atlas/sql/schema"
"ariga.io/atlas/sql/sqlcheck"
)
type (
// Analyzer checks data-dependent changes.
Analyzer struct {
sqlcheck.Options
Handler
}
// Handler holds the underlying driver handlers.
Handler struct {
// AddNotNull is applied when a new non-nullable column was
// added to an existing table.
AddNotNull ColumnHandler
// ModifyNotNull is an optional handler applied when
// a nullable column was changed to non-nullable.
ModifyNotNull ColumnHandler
}
// ColumnPass wraps the information needed
// by the handler below to diagnose columns.
ColumnPass struct {
*sqlcheck.Pass
Change *sqlcheck.Change // Change context (statement).
Table *schema.Table // The table this column belongs to.
Column *schema.Column // The diagnosed column.
}
// ColumnHandler allows provide custom diagnostic for specific column rules.
ColumnHandler func(*ColumnPass) ([]sqlcheck.Diagnostic, error)
)
// New creates a new data-dependent analyzer with the given options.
func New(r *schemahcl.Resource, h Handler) (*Analyzer, error) {
az := &Analyzer{Handler: h}
if r, ok := r.Resource(az.Name()); ok {
if err := r.As(&az.Options); err != nil {
return nil, fmt.Errorf("sql/sqlcheck: parsing datadepend check options: %w", err)
}
}
return az, nil
}
// Name of the analyzer. Implements the sqlcheck.NamedAnalyzer interface.
func (*Analyzer) Name() string {
return "data_depend"
}
// Analyze runs data-depend analysis on MySQL changes.
func (a *Analyzer) Analyze(ctx context.Context, p *sqlcheck.Pass) error {
return a.Report(p, a.Diagnostics(ctx, p))
}
// List of codes.
var (
codeAddUniqueI = sqlcheck.Code("MF101")
codeModUniqueI = sqlcheck.Code("MF102")
codeAddNotNullC = sqlcheck.Code("MF103")
codeModNotNullC = sqlcheck.Code("MF104")
)
// Diagnostics runs the common analysis on the file and returns its diagnostics.
func (a *Analyzer) Diagnostics(_ context.Context, p *sqlcheck.Pass) (diags []sqlcheck.Diagnostic) {
for _, sc := range p.File.Changes {
for _, c := range sc.Changes {
m, ok := c.(*schema.ModifyTable)
if !ok {
continue
}
for _, c := range m.Changes {
switch c := c.(type) {
case *schema.AddIndex:
column := func() *schema.Column {
for i := range c.I.Parts {
// We consider a column a non-new column if
// it was not added in this migration file.
if column := c.I.Parts[i].C; column != nil && p.File.ColumnSpan(m.T, column)&sqlcheck.SpanAdded == 0 {
return column
}
}
return nil
}()
// A unique index was added on an existing column.
if c.I.Unique && column != nil {
diags = append(diags, sqlcheck.Diagnostic{
Code: codeAddUniqueI,
Pos: sc.Stmt.Pos,
Text: fmt.Sprintf("Adding a unique index %q on table %q might fail in case column %q contains duplicate entries", c.I.Name, m.T.Name, column.Name),
})
}
case *schema.ModifyIndex:
if c.Change.Is(schema.ChangeUnique) && c.To.Unique && p.File.IndexSpan(m.T, c.To)&sqlcheck.SpanAdded == 0 {
diags = append(diags, sqlcheck.Diagnostic{
Code: codeModUniqueI,
Pos: sc.Stmt.Pos,
Text: fmt.Sprintf("Modifying an index %q on table %q might fail in case of duplicate entries", c.To.Name, m.T.Name),
})
}
case *schema.AddColumn:
// In case the column is nullable without default
// value and the table was not added in this file.
if a.Handler.AddNotNull != nil && !c.C.Type.Null && c.C.Default == nil && p.File.TableSpan(m.T)&sqlcheck.SpanAdded != 1 {
d, err := a.Handler.AddNotNull(&ColumnPass{Pass: p, Change: sc, Table: m.T, Column: c.C})
if err != nil {
return
}
for i := range d {
// In case there is no driver-specific code.
if d[i].Code == "" {
d[i].Code = codeAddNotNullC
}
}
diags = append(diags, d...)
}
case *schema.ModifyColumn:
switch {
case p.File.TableSpan(m.T)&sqlcheck.SpanAdded == 1 || !(c.From.Type.Null && !c.To.Type.Null):
case a.ModifyNotNull != nil:
d, err := a.Handler.ModifyNotNull(&ColumnPass{Pass: p, Change: sc, Table: m.T, Column: c.To})
if err != nil {
return
}
for i := range d {
// In case there is no driver-specific code.
if d[i].Code == "" {
d[i].Code = codeModNotNullC
}
}
diags = append(diags, d...)
// In case the altered column was not added in this file, and the column
// was changed nullable to non-nullable without back filling it with values.
case !ColumnFilled(p.File, m.T, c.From, sc.Stmt.Pos):
diags = append(diags, sqlcheck.Diagnostic{
Code: codeModNotNullC,
Pos: sc.Stmt.Pos,
Text: fmt.Sprintf("Modifying nullable column %q to non-nullable might fail in case it contains NULL values", c.To.Name),
})
}
}
}
}
}
return
}
// Report provides standard reporting for data-dependent changes. Drivers that
// decorate this Analyzer should call this function to get consistent reporting
// between dialects.
func (a *Analyzer) Report(p *sqlcheck.Pass, diags []sqlcheck.Diagnostic) error {
const reportText = "data dependent changes detected"
if len(diags) > 0 {
p.Reporter.WriteReport(sqlcheck.Report{Text: reportText, Diagnostics: diags})
if sqlx.V(a.Error) {
return errors.New(reportText)
}
}
return nil
}
// ColumnFilled checks if the column was filled with values before the given position.
func ColumnFilled(f *sqlcheck.File, t *schema.Table, c *schema.Column, pos int) bool {
// The parser used for parsing this file can check if the
// given nullable column was filled before the given position.
p, ok := f.Parser.(interface {
ColumnFilledBefore(migrate.File, *schema.Table, *schema.Column, int) (bool, error)
})
if !ok {
return false
}
filled, _ := p.ColumnFilledBefore(f, t, c, pos)
return filled
}
atlas-0.7.2/sql/sqlcheck/datadepend/datadepend_test.go 0000664 0000000 0000000 00000015103 14314555116 0022775 0 ustar 00root root 0000000 0000000 // Copyright 2021-present The Atlas Authors. All rights reserved.
// This source code is licensed under the Apache 2.0 license found
// in the LICENSE file in the root directory of this source tree.
package datadepend_test
import (
"context"
"testing"
"ariga.io/atlas/schemahcl"
"ariga.io/atlas/sql/internal/specutil"
"ariga.io/atlas/sql/migrate"
"ariga.io/atlas/sql/schema"
"ariga.io/atlas/sql/sqlcheck"
"ariga.io/atlas/sql/sqlcheck/datadepend"
"ariga.io/atlas/sql/sqlclient"
"github.com/stretchr/testify/require"
)
func TestAnalyzer_AddUniqueIndex(t *testing.T) {
var (
report *sqlcheck.Report
pass = &sqlcheck.Pass{
Dev: &sqlclient.Client{},
File: &sqlcheck.File{
File: testFile{name: "1.sql"},
Changes: []*sqlcheck.Change{
{
Stmt: &migrate.Stmt{
Text: "ALTER TABLE users",
},
Changes: schema.Changes{
&schema.ModifyTable{
T: schema.NewTable("users").
SetSchema(schema.New("test")).
AddColumns(
schema.NewColumn("a"),
schema.NewColumn("b"),
),
Changes: []schema.Change{
// Ignore new created columns.
&schema.AddColumn{
C: schema.NewColumn("a"),
},
&schema.AddIndex{
I: schema.NewUniqueIndex("idx_a").
AddColumns(schema.NewColumn("a")),
},
// Report on existing columns.
&schema.AddIndex{
I: schema.NewUniqueIndex("idx_b").
AddColumns(schema.NewColumn("b")),
},
},
},
},
},
},
},
Reporter: sqlcheck.ReportWriterFunc(func(r sqlcheck.Report) {
report = &r
}),
}
)
az, err := datadepend.New(nil, datadepend.Handler{})
require.NoError(t, err)
err = az.Analyze(context.Background(), pass)
require.NoError(t, err)
require.Equal(t, "data dependent changes detected", report.Text)
require.Len(t, report.Diagnostics, 1)
require.Equal(t, `Adding a unique index "idx_b" on table "users" might fail in case column "b" contains duplicate entries`, report.Diagnostics[0].Text)
}
func TestAnalyzer_ModifyUniqueIndex(t *testing.T) {
var (
report *sqlcheck.Report
pass = &sqlcheck.Pass{
Dev: &sqlclient.Client{},
File: &sqlcheck.File{
File: testFile{name: "1.sql"},
Changes: []*sqlcheck.Change{
{
Stmt: &migrate.Stmt{
Text: "ALTER TABLE users",
},
Changes: schema.Changes{
&schema.ModifyTable{
T: schema.NewTable("users").
SetSchema(schema.New("test")).
AddColumns(
schema.NewColumn("a"),
schema.NewColumn("b"),
),
Changes: []schema.Change{
// Ignore new created columns.
&schema.AddColumn{
C: schema.NewColumn("a"),
},
&schema.ModifyIndex{
From: schema.NewIndex("idx_a").
AddColumns(schema.NewColumn("a")),
To: schema.NewUniqueIndex("idx_a").
AddColumns(schema.NewColumn("a")),
},
// Report on existing columns.
&schema.ModifyIndex{
From: schema.NewIndex("idx_b").
AddColumns(schema.NewColumn("b")),
To: schema.NewUniqueIndex("idx_b").
AddColumns(schema.NewColumn("b")),
Change: schema.ChangeUnique,
},
},
},
},
},
},
},
Reporter: sqlcheck.ReportWriterFunc(func(r sqlcheck.Report) {
report = &r
}),
}
)
az, err := datadepend.New(nil, datadepend.Handler{})
require.NoError(t, err)
err = az.Analyze(context.Background(), pass)
require.NoError(t, err)
require.Equal(t, "data dependent changes detected", report.Text)
require.Len(t, report.Diagnostics, 1)
require.Equal(t, `Modifying an index "idx_b" on table "users" might fail in case of duplicate entries`, report.Diagnostics[0].Text)
}
func TestAnalyzer_ModifyNullability(t *testing.T) {
var (
report *sqlcheck.Report
pass = &sqlcheck.Pass{
Dev: &sqlclient.Client{},
File: &sqlcheck.File{
File: testFile{name: "1.sql"},
Changes: []*sqlcheck.Change{
{
Stmt: &migrate.Stmt{
Text: "ALTER TABLE users",
},
Changes: schema.Changes{
&schema.ModifyTable{
T: schema.NewTable("users").
SetSchema(schema.New("test")).
AddColumns(
schema.NewNullIntColumn("a", "int"),
),
Changes: []schema.Change{
&schema.ModifyColumn{
From: schema.NewNullIntColumn("a", "int"),
To: schema.NewIntColumn("a", "int"),
Change: schema.ChangeNull,
},
},
},
},
},
},
},
Reporter: sqlcheck.ReportWriterFunc(func(r sqlcheck.Report) {
report = &r
}),
}
)
az, err := datadepend.New(nil, datadepend.Handler{})
require.NoError(t, err)
err = az.Analyze(context.Background(), pass)
require.NoError(t, err)
require.Equal(t, "data dependent changes detected", report.Text)
require.Len(t, report.Diagnostics, 1)
require.Equal(t, `Modifying nullable column "a" to non-nullable might fail in case it contains NULL values`, report.Diagnostics[0].Text)
}
func TestAnalyzer_Options(t *testing.T) {
var (
report *sqlcheck.Report
pass = &sqlcheck.Pass{
Dev: &sqlclient.Client{},
File: &sqlcheck.File{
File: testFile{name: "1.sql"},
Changes: []*sqlcheck.Change{
{
Stmt: &migrate.Stmt{
Text: "ALTER TABLE users",
},
Changes: schema.Changes{
&schema.ModifyTable{
T: schema.NewTable("users").
SetSchema(schema.New("test")).
AddColumns(
schema.NewColumn("a"),
schema.NewColumn("b"),
),
Changes: []schema.Change{
&schema.AddIndex{
I: schema.NewIndex("idx_a").
AddColumns(schema.NewColumn("a")),
},
&schema.ModifyIndex{
From: schema.NewIndex("idx_b").
AddColumns(schema.NewColumn("b")),
To: schema.NewUniqueIndex("idx_b").
AddColumns(schema.NewColumn("b")),
Change: schema.ChangeUnique,
},
},
},
},
},
},
},
Reporter: sqlcheck.ReportWriterFunc(func(r sqlcheck.Report) {
report = &r
}),
}
)
az, err := datadepend.New(&schemahcl.Resource{
Children: []*schemahcl.Resource{
{
Type: "data_depend",
Attrs: []*schemahcl.Attr{
specutil.BoolAttr("error", true),
},
},
},
}, datadepend.Handler{})
require.NoError(t, err)
err = az.Analyze(context.Background(), pass)
require.EqualError(t, err, "data dependent changes detected")
require.NotNil(t, report)
}
type testFile struct {
name string
migrate.File
}
func (t testFile) Name() string {
return t.name
}
atlas-0.7.2/sql/sqlcheck/destructive/ 0000775 0000000 0000000 00000000000 14314555116 0017566 5 ustar 00root root 0000000 0000000 atlas-0.7.2/sql/sqlcheck/destructive/destructive.go 0000664 0000000 0000000 00000005622 14314555116 0022463 0 ustar 00root root 0000000 0000000 // Copyright 2021-present The Atlas Authors. All rights reserved.
// This source code is licensed under the Apache 2.0 license found
// in the LICENSE file in the root directory of this source tree.
package destructive
import (
"context"
"errors"
"fmt"
"strings"
"ariga.io/atlas/schemahcl"
"ariga.io/atlas/sql/internal/sqlx"
"ariga.io/atlas/sql/schema"
"ariga.io/atlas/sql/sqlcheck"
)
// Analyzer checks for destructive changes.
type Analyzer struct {
sqlcheck.Options
}
// New creates a new destructive changes Analyzer with the given options.
func New(r *schemahcl.Resource) (*Analyzer, error) {
az := &Analyzer{}
az.Error = sqlx.P(true)
if r, ok := r.Resource(az.Name()); ok {
if err := r.As(&az.Options); err != nil {
return nil, fmt.Errorf("sql/sqlcheck: parsing destructive check options: %w", err)
}
}
return az, nil
}
// List of codes.
var (
codeDropS = sqlcheck.Code("DS101")
codeDropT = sqlcheck.Code("DS102")
codeDropC = sqlcheck.Code("DS103")
)
// Name of the analyzer. Implements the sqlcheck.NamedAnalyzer interface.
func (*Analyzer) Name() string {
return "destructive"
}
// Analyze implements sqlcheck.Analyzer.
func (a *Analyzer) Analyze(_ context.Context, p *sqlcheck.Pass) error {
var diags []sqlcheck.Diagnostic
for _, sc := range p.File.Changes {
for _, c := range sc.Changes {
switch c := c.(type) {
case *schema.DropSchema:
if p.File.SchemaSpan(c.S) != sqlcheck.SpanTemporary {
var text string
switch n := len(c.S.Tables); {
case n == 0:
text = fmt.Sprintf("Dropping schema %q", c.S.Name)
case n == 1:
text = fmt.Sprintf("Dropping non-empty schema %q with 1 table", c.S.Name)
case n > 1:
text = fmt.Sprintf("Dropping non-empty schema %q with %d tables", c.S.Name, n)
}
diags = append(diags, sqlcheck.Diagnostic{
Code: codeDropS,
Pos: sc.Stmt.Pos,
Text: text,
})
}
case *schema.DropTable:
if p.File.SchemaSpan(c.T.Schema) != sqlcheck.SpanDropped && p.File.TableSpan(c.T) != sqlcheck.SpanTemporary {
diags = append(diags, sqlcheck.Diagnostic{
Code: codeDropT,
Pos: sc.Stmt.Pos,
Text: fmt.Sprintf("Dropping table %q", c.T.Name),
})
}
case *schema.ModifyTable:
for i := range c.Changes {
d, ok := c.Changes[i].(*schema.DropColumn)
if !ok || p.File.ColumnSpan(c.T, d.C) == sqlcheck.SpanTemporary {
continue
}
if g := (schema.GeneratedExpr{}); !sqlx.Has(d.C.Attrs, &g) || strings.ToUpper(g.Type) != "VIRTUAL" {
diags = append(diags, sqlcheck.Diagnostic{
Code: codeDropC,
Pos: sc.Stmt.Pos,
Text: fmt.Sprintf("Dropping non-virtual column %q", d.C.Name),
})
}
}
}
}
}
if len(diags) > 0 {
const reportText = "destructive changes detected"
p.Reporter.WriteReport(sqlcheck.Report{Text: reportText, Diagnostics: diags})
if sqlx.V(a.Error) {
return errors.New(reportText)
}
}
return nil
}
atlas-0.7.2/sql/sqlcheck/destructive/destructive_test.go 0000664 0000000 0000000 00000014037 14314555116 0023522 0 ustar 00root root 0000000 0000000 // Copyright 2021-present The Atlas Authors. All rights reserved.
// This source code is licensed under the Apache 2.0 license found
// in the LICENSE file in the root directory of this source tree.
package destructive_test
import (
"context"
"testing"
"ariga.io/atlas/schemahcl"
"ariga.io/atlas/sql/internal/specutil"
"ariga.io/atlas/sql/migrate"
"ariga.io/atlas/sql/schema"
"ariga.io/atlas/sql/sqlcheck"
"ariga.io/atlas/sql/sqlcheck/destructive"
"ariga.io/atlas/sql/sqlclient"
"github.com/stretchr/testify/require"
)
func TestAnalyzer_DropTable(t *testing.T) {
var (
report *sqlcheck.Report
pass = &sqlcheck.Pass{
Dev: &sqlclient.Client{},
File: &sqlcheck.File{
File: testFile{name: "1.sql"},
Changes: []*sqlcheck.Change{
{
Stmt: &migrate.Stmt{
Text: "DROP TABLE `users`",
},
Changes: schema.Changes{
&schema.DropTable{
T: schema.NewTable("users").
SetSchema(schema.New("test")),
},
},
},
{
Stmt: &migrate.Stmt{
Text: "DROP TABLE `posts`",
},
Changes: schema.Changes{
&schema.DropTable{
T: schema.NewTable("posts").
SetSchema(schema.New("test")),
},
},
},
{
Stmt: &migrate.Stmt{
Text: "CREATE TABLE `posts`",
},
Changes: schema.Changes{
&schema.AddTable{
T: schema.NewTable("posts").
SetSchema(schema.New("test")),
},
},
},
},
},
Reporter: sqlcheck.ReportWriterFunc(func(r sqlcheck.Report) {
report = &r
}),
}
)
az, err := destructive.New(nil)
require.NoError(t, err)
err = az.Analyze(context.Background(), pass)
require.Error(t, err)
require.Equal(t, "destructive changes detected", report.Text)
require.Len(t, report.Diagnostics, 2)
require.Equal(t, `Dropping table "users"`, report.Diagnostics[0].Text)
require.Equal(t, `Dropping table "posts"`, report.Diagnostics[1].Text)
}
func TestAnalyzer_SkipTemporaryTable(t *testing.T) {
var (
report *sqlcheck.Report
pass = &sqlcheck.Pass{
Dev: &sqlclient.Client{},
File: &sqlcheck.File{
File: testFile{name: "1.sql"},
Changes: []*sqlcheck.Change{
{
Stmt: &migrate.Stmt{
Text: "DROP TABLE `users`",
},
Changes: schema.Changes{
&schema.AddTable{
T: schema.NewTable("users").
SetSchema(schema.New("test")),
},
&schema.DropTable{
T: schema.NewTable("users").
SetSchema(schema.New("test")),
},
},
},
},
},
Reporter: sqlcheck.ReportWriterFunc(func(r sqlcheck.Report) {
report = &r
}),
}
)
az, err := destructive.New(nil)
require.NoError(t, err)
err = az.Analyze(context.Background(), pass)
require.NoError(t, err)
require.Nil(t, report, "no report")
}
func TestAnalyzer_DropSchema(t *testing.T) {
var (
report *sqlcheck.Report
pass = &sqlcheck.Pass{
Dev: &sqlclient.Client{},
File: &sqlcheck.File{
File: testFile{name: "1.sql"},
Changes: []*sqlcheck.Change{
{
Stmt: &migrate.Stmt{
Text: "DROP SCHEMA `test`",
},
Changes: schema.Changes{
&schema.DropSchema{
S: schema.New("test").
AddTables(
schema.NewTable("users"),
schema.NewTable("orders"),
),
},
},
},
{
Stmt: &migrate.Stmt{
Text: "DROP SCHEMA `market`",
},
Changes: schema.Changes{
&schema.DropSchema{
S: schema.New("market"),
},
},
},
{
Stmt: &migrate.Stmt{
Text: "CREATE DATABASE `market`",
},
Changes: schema.Changes{
&schema.AddSchema{
S: schema.New("market"),
},
},
},
},
},
Reporter: sqlcheck.ReportWriterFunc(func(r sqlcheck.Report) {
report = &r
}),
}
)
az, err := destructive.New(&schemahcl.Resource{
Children: []*schemahcl.Resource{
{
Type: "destructive",
Attrs: []*schemahcl.Attr{
specutil.BoolAttr("error", false),
},
},
},
})
require.NoError(t, err)
err = az.Analyze(context.Background(), pass)
require.NoError(t, err)
require.Equal(t, "destructive changes detected", report.Text)
require.Len(t, report.Diagnostics, 2)
require.Equal(t, `Dropping non-empty schema "test" with 2 tables`, report.Diagnostics[0].Text)
require.Equal(t, `Dropping schema "market"`, report.Diagnostics[1].Text)
}
func TestAnalyzer_DropColumn(t *testing.T) {
var (
report sqlcheck.Report
pass = &sqlcheck.Pass{
Dev: &sqlclient.Client{Name: "mysql"},
File: &sqlcheck.File{
File: testFile{name: "1.sql"},
Changes: []*sqlcheck.Change{
{
Stmt: &migrate.Stmt{
Text: "ALTER TABLE `pets`",
},
Changes: []schema.Change{
&schema.ModifyTable{
T: schema.NewTable("pets").
SetSchema(schema.New("test")),
Changes: schema.Changes{
&schema.DropColumn{
C: schema.NewColumn("c").
SetGeneratedExpr(&schema.GeneratedExpr{Type: "STORED"}),
},
},
},
},
},
{
Stmt: &migrate.Stmt{
Text: "ALTER TABLE `pets`",
},
Changes: []schema.Change{
&schema.ModifySchema{
S: schema.New("test"),
Changes: schema.Changes{
&schema.ModifyAttr{
From: &schema.Charset{V: "utf8"},
To: &schema.Charset{V: "latin1"},
},
},
},
},
},
},
},
Reporter: sqlcheck.ReportWriterFunc(func(r sqlcheck.Report) {
report = r
}),
}
)
az, err := destructive.New(&schemahcl.Resource{
Children: []*schemahcl.Resource{
{
Type: "destructive",
Attrs: []*schemahcl.Attr{
specutil.BoolAttr("error", false),
},
},
},
})
require.NoError(t, err)
err = az.Analyze(context.Background(), pass)
require.NoError(t, err)
require.Len(t, report.Diagnostics, 1)
require.Equal(t, "destructive changes detected", report.Text)
require.Equal(t, `Dropping non-virtual column "c"`, report.Diagnostics[0].Text)
}
type testFile struct {
name string
migrate.File
}
func (t testFile) Name() string {
return t.name
}
atlas-0.7.2/sql/sqlcheck/sqlcheck.go 0000664 0000000 0000000 00000017556 14314555116 0017367 0 ustar 00root root 0000000 0000000 // Copyright 2021-present The Atlas Authors. All rights reserved.
// This source code is licensed under the Apache 2.0 license found
// in the LICENSE file in the root directory of this source tree.
// Package sqlcheck provides interfaces for analyzing the contents of SQL files
// to generate insights on the safety of many kinds of changes to database
// schemas. With this package developers may define an Analyzer that can be used
// to diagnose the impact of SQL statements on the target database. For instance,
// The `destructive` package exposes an Analyzer that detects destructive changes
// to the database schema, such as the dropping of tables or columns.
package sqlcheck
import (
"context"
"sync"
"ariga.io/atlas/schemahcl"
"ariga.io/atlas/sql/migrate"
"ariga.io/atlas/sql/schema"
"ariga.io/atlas/sql/sqlclient"
)
type (
// An Analyzer describes a migration file analyzer.
Analyzer interface {
// Analyze executes the analysis function.
Analyze(context.Context, *Pass) error
}
// A NamedAnalyzer describes an Analyzer that has a name.
NamedAnalyzer interface {
Analyzer
// Name of the analyzer. Identifies the analyzer
// in configuration and linting passes.
Name() string
}
// A Pass provides information to the Run function that
// applies a specific analyzer to an SQL file.
Pass struct {
// A migration file and the changes it describes.
File *File
// Dev is a driver-specific environment used to execute analysis work.
Dev *sqlclient.Client
// Report reports analysis reports.
Reporter ReportWriter
}
// File represents a parsed version of a migration file.
File struct {
migrate.File
// Changes represents the list of changes this file represents.
Changes []*Change
// Sum represents a summary of changes this file represents. For example,
// in case of a file that contains exactly two statements, and the first
// statement is reverted by the one after it, the Sum is nil.
Sum schema.Changes
// A Parser that may be used for parsing this file. It sets to any as the contract
// between checks and their parsers can vary. For example, in case of running checks
// from CLI, the injected parser can be found in cmd/atlas/internal/sqlparse.Parser.
Parser any
// schema spans. lazily initialized.
spans map[string]*schemaSpan
}
// A Change in a migration file.
Change struct {
schema.Changes // The actual changes.
Stmt *migrate.Stmt // The SQL statement generated this change.
}
// A Report describes an analysis report with an optional specific diagnostic.
Report struct {
Text string // Report text.
Diagnostics []Diagnostic // Report diagnostics.
}
// A Diagnostic is a text associated with a specific position of a statement in a file.
Diagnostic struct {
Pos int // Diagnostic position.
Text string // Diagnostic text.
Code string // Code describes the check. For example, DS101
}
// ReportWriter represents a writer for analysis reports.
ReportWriter interface {
WriteReport(Report)
}
// Options defines a generic configuration options for analyzers.
Options struct {
// Error indicates if an analyzer should
// error in case a Diagnostic was found.
Error *bool `spec:"error"`
// Allow drivers to extend the configuration.
schemahcl.DefaultExtension
}
)
// Analyzers implements Analyzer.
type Analyzers []Analyzer
// Analyze implements Analyzer.
func (a Analyzers) Analyze(ctx context.Context, p *Pass) error {
for _, a := range a {
if err := a.Analyze(ctx, p); err != nil {
return err
}
}
return nil
}
// AnalyzerFunc allows using ordinary functions as analyzers.
type AnalyzerFunc func(ctx context.Context, p *Pass) error
// Analyze calls f.
func (f AnalyzerFunc) Analyze(ctx context.Context, p *Pass) error {
return f(ctx, p)
}
// ReportWriterFunc is a function that implements Reporter.
type ReportWriterFunc func(Report)
// WriteReport calls f(r).
func (f ReportWriterFunc) WriteReport(r Report) {
f(r)
}
// ResourceSpan describes the lifespan of a resource
// in perspective to the migration file.
type ResourceSpan uint
const (
// SpanUnknown describes unknown lifespan.
// e.g. resource may exist before this file.
SpanUnknown ResourceSpan = iota
// SpanAdded describes that a span of
// a resource was started in this file.
SpanAdded
// SpanDropped describes that a span of
// a resource was ended in this file.
SpanDropped
// SpanTemporary indicates that a resource lifetime
// was started and ended in this file (CREATE and DROP).
SpanTemporary = SpanAdded | SpanDropped
)
// SchemaSpan returns the span information for the schema.
func (f *File) SchemaSpan(s *schema.Schema) ResourceSpan {
return f.schemaSpan(s).state
}
// TableSpan returns the span information for the table.
func (f *File) TableSpan(t *schema.Table) ResourceSpan {
return f.tableSpan(t).state
}
// ColumnSpan returns the span information for the column.
func (f *File) ColumnSpan(t *schema.Table, c *schema.Column) ResourceSpan {
return f.tableSpan(t).columns[c.Name]
}
// IndexSpan returns the span information for the span.
func (f *File) IndexSpan(t *schema.Table, i *schema.Index) ResourceSpan {
return f.tableSpan(t).indexes[i.Name]
}
type (
// schemaSpan holds the span structure of a schema.
schemaSpan struct {
state ResourceSpan
tables map[string]*tableSpan
}
// schemaSpan holds the span structure of a table.
tableSpan struct {
state ResourceSpan
columns map[string]ResourceSpan
indexes map[string]ResourceSpan
}
)
func (f *File) loadSpans() {
f.spans = make(map[string]*schemaSpan)
for _, sc := range f.Changes {
for _, c := range sc.Changes {
switch c := c.(type) {
case *schema.AddSchema:
f.schemaSpan(c.S).state = SpanAdded
case *schema.DropSchema:
f.schemaSpan(c.S).state |= SpanDropped
case *schema.AddTable:
span := f.tableSpan(c.T)
span.state = SpanAdded
for _, column := range c.T.Columns {
span.columns[column.Name] = SpanAdded
}
for _, idx := range c.T.Indexes {
span.indexes[idx.Name] = SpanAdded
}
case *schema.DropTable:
f.tableSpan(c.T).state |= SpanDropped
case *schema.ModifyTable:
span := f.tableSpan(c.T)
for _, c1 := range c.Changes {
switch c1 := c1.(type) {
case *schema.AddColumn:
span.columns[c1.C.Name] = SpanAdded
case *schema.DropColumn:
span.columns[c1.C.Name] |= SpanDropped
case *schema.AddIndex:
span.indexes[c1.I.Name] = SpanAdded
case *schema.DropIndex:
span.indexes[c1.I.Name] |= SpanDropped
}
}
}
}
}
}
func (f *File) schemaSpan(s *schema.Schema) *schemaSpan {
if f.spans == nil {
f.loadSpans()
}
if f.spans[s.Name] == nil {
f.spans[s.Name] = &schemaSpan{tables: make(map[string]*tableSpan)}
}
return f.spans[s.Name]
}
func (f *File) tableSpan(t *schema.Table) *tableSpan {
span := f.schemaSpan(t.Schema)
if span.tables[t.Name] == nil {
span.tables[t.Name] = &tableSpan{
columns: make(map[string]ResourceSpan),
indexes: make(map[string]ResourceSpan),
}
}
return f.spans[t.Schema.Name].tables[t.Name]
}
// codes registry
var codes sync.Map
// Code stores the given code in the registry.
// It protects from duplicate analyzers' codes.
func Code(code string) string {
if _, loaded := codes.LoadOrStore(code, struct{}{}); loaded {
panic("sqlcheck: Code called twice for " + code)
}
return code
}
// drivers specific analyzers.
var drivers sync.Map
// Register allows drivers to register a constructor function for creating
// analyzers from the given HCL resource.
func Register(name string, f func(*schemahcl.Resource) ([]Analyzer, error)) {
drivers.Store(name, f)
}
// AnalyzerFor instantiates a new Analyzer from the given HCL resource
// based on the registered constructor function.
func AnalyzerFor(name string, r *schemahcl.Resource) ([]Analyzer, error) {
f, ok := drivers.Load(name)
if ok {
return f.(func(*schemahcl.Resource) ([]Analyzer, error))(r)
}
return nil, nil
}
atlas-0.7.2/sql/sqlclient/ 0000775 0000000 0000000 00000000000 14314555116 0015426 5 ustar 00root root 0000000 0000000 atlas-0.7.2/sql/sqlclient/client.go 0000664 0000000 0000000 00000024564 14314555116 0017246 0 ustar 00root root 0000000 0000000 // Copyright 2021-present The Atlas Authors. All rights reserved.
// This source code is licensed under the Apache 2.0 license found
// in the LICENSE file in the root directory of this source tree.
package sqlclient
import (
"context"
"database/sql"
"errors"
"fmt"
"io"
"net/url"
"sync"
"ariga.io/atlas/schemahcl"
"ariga.io/atlas/sql/migrate"
"ariga.io/atlas/sql/schema"
)
type (
// Client provides the common functionalities for working with Atlas from different
// applications (e.g. CLI and TF). Note, the Client is dialect specific and should
// be instantiated using a call to Open.
Client struct {
// Name used when creating the client.
Name string
// DB used for creating the client.
DB *sql.DB
// URL holds an enriched url.URL.
URL *URL
// A migration driver for the attached dialect.
migrate.Driver
// Additional closers that can be closed at the
// end of the client lifetime.
closers []io.Closer
// Marshal and Evaluator functions for decoding
// and encoding the schema documents.
schemahcl.Marshaler
schemahcl.Evaluator
// Functions registered by the drivers and used for opening transactions and their clients.
openDriver func(schema.ExecQuerier) (migrate.Driver, error)
openTx TxOpener
}
// TxClient is returned by calling Client.Tx. It behaves the same as Client,
// but wraps all operations within a transaction.
TxClient struct {
*Client
// The transaction this Client wraps.
Tx *Tx
}
// URL extends the standard url.URL with additional
// connection information attached by the Opener (if any).
URL struct {
*url.URL
// The DSN used for opening the connection.
DSN string
// The Schema this client is connected to.
Schema string
}
)
// Tx returns a transactional client.
func (c *Client) Tx(ctx context.Context, opts *sql.TxOptions) (*TxClient, error) {
if c.openDriver == nil {
return nil, errors.New("sql/sqlclient: unexpected driver opener: ")
}
var tx *Tx
switch {
case c.openTx != nil:
ttx, err := c.openTx(ctx, c.DB, opts)
if err != nil {
return nil, err
}
tx = ttx
default:
ttx, err := c.DB.BeginTx(ctx, opts)
if err != nil {
return nil, fmt.Errorf("sql/sqlclient: starting transaction: %w", err)
}
tx = &Tx{Tx: ttx}
}
drv, err := c.openDriver(tx)
if err != nil {
return nil, fmt.Errorf("sql/sqlclient: opening atlas driver: %w", err)
}
ic := *c
ic.Driver = drv
return &TxClient{Client: &ic, Tx: tx}, nil
}
// Commit the transaction.
func (c *TxClient) Commit() error {
return c.Tx.Commit()
}
// Rollback the transaction.
func (c *TxClient) Rollback() error {
return c.Tx.Rollback()
}
// AddClosers adds list of closers to close at the end of the client lifetime.
func (c *Client) AddClosers(closers ...io.Closer) {
c.closers = append(c.closers, closers...)
}
// Close closes the underlying database connection and the migration
// driver in case it implements the io.Closer interface.
func (c *Client) Close() (err error) {
for _, closer := range append(c.closers, c.DB) {
if cerr := closer.Close(); cerr != nil {
if err != nil {
cerr = fmt.Errorf("%v: %v", err, cerr)
}
err = cerr
}
}
return err
}
type (
// Opener opens a migration driver by the given URL.
Opener interface {
Open(ctx context.Context, u *url.URL) (*Client, error)
}
// OpenerFunc allows using a function as an Opener.
OpenerFunc func(context.Context, *url.URL) (*Client, error)
// URLParser parses an url.URL into an enriched URL and attaches additional info to it.
URLParser interface {
ParseURL(*url.URL) *URL
}
// URLParserFunc allows using a function as an URLParser.
URLParserFunc func(*url.URL) *URL
// SchemaChanger is implemented by a driver if it how to change the connection URL to represent another schema.
SchemaChanger interface {
ChangeSchema(*url.URL, string) *url.URL
}
driver struct {
Opener
name string
parser URLParser
txOpener TxOpener
}
)
// Open calls f(ctx, u).
func (f OpenerFunc) Open(ctx context.Context, u *url.URL) (*Client, error) {
return f(ctx, u)
}
// ParseURL calls f(u).
func (f URLParserFunc) ParseURL(u *url.URL) *URL {
return f(u)
}
var drivers sync.Map
type (
// openOptions holds additional configuration values for opening a Client.
openOptions struct {
schema *string
}
// OpenOption allows to configure a openOptions using functional arguments.
OpenOption func(*openOptions) error
)
// ErrUnsupported is returned if a registered driver does not support changing the schema.
var ErrUnsupported = errors.New("sql/sqlclient: driver does not support changing connected schema")
// Open opens an Atlas client by its provided url string.
func Open(ctx context.Context, s string, opts ...OpenOption) (*Client, error) {
u, err := url.Parse(s)
if err != nil {
return nil, fmt.Errorf("sql/sqlclient: parse open url: %w", err)
}
return OpenURL(ctx, u, opts...)
}
// OpenURL opens an Atlas client by its provided url.URL.
func OpenURL(ctx context.Context, u *url.URL, opts ...OpenOption) (*Client, error) {
cfg := &openOptions{}
for _, opt := range opts {
if err := opt(cfg); err != nil {
return nil, err
}
}
v, ok := drivers.Load(u.Scheme)
if !ok {
return nil, fmt.Errorf("sql/sqlclient: no opener was register with name %q", u.Scheme)
}
drv := v.(*driver)
// If there is a schema given and the driver allows to change the schema for the url, do it.
if cfg.schema != nil {
sc, ok := drv.parser.(SchemaChanger)
if !ok {
return nil, ErrUnsupported
}
u = sc.ChangeSchema(u, *cfg.schema)
}
client, err := drv.Open(ctx, u)
if err != nil {
return nil, err
}
if client.URL == nil {
client.URL = drv.parser.ParseURL(u)
}
if client.openTx == nil && drv.txOpener != nil {
client.openTx = drv.txOpener
}
return client, nil
}
// OpenSchema opens the connection to the given schema.
// If the registered driver does not support this, ErrUnsupported is returned instead.
func OpenSchema(s string) OpenOption {
return func(c *openOptions) error {
c.schema = &s
return nil
}
}
type (
registerOptions struct {
openDriver func(schema.ExecQuerier) (migrate.Driver, error)
txOpener TxOpener
parser URLParser
flavours []string
codec interface {
schemahcl.Marshaler
schemahcl.Evaluator
}
}
// RegisterOption allows configuring the Opener
// registration using functional options.
RegisterOption func(*registerOptions)
)
// RegisterFlavours allows registering additional flavours
// (i.e. names), accepted by Atlas to open clients.
func RegisterFlavours(flavours ...string) RegisterOption {
return func(opts *registerOptions) {
opts.flavours = flavours
}
}
// RegisterURLParser allows registering a function for parsing
// the url.URL and attach additional info to the extended URL.
func RegisterURLParser(p URLParser) RegisterOption {
return func(opts *registerOptions) {
opts.parser = p
}
}
// RegisterCodec registers static codec for attaching into
// the client after it is opened.
func RegisterCodec(m schemahcl.Marshaler, e schemahcl.Evaluator) RegisterOption {
return func(opts *registerOptions) {
opts.codec = struct {
schemahcl.Marshaler
schemahcl.Evaluator
}{
Marshaler: m,
Evaluator: e,
}
}
}
// RegisterDriverOpener registers a func to create a migrate.Driver from a schema.ExecQuerier.
// Registering this function is implicitly done when using DriverOpener.
// The passed opener is used when creating a TxClient.
func RegisterDriverOpener(open func(schema.ExecQuerier) (migrate.Driver, error)) RegisterOption {
return func(opts *registerOptions) {
opts.openDriver = open
}
}
// DriverOpener is a helper Opener creator for sharing between all drivers.
func DriverOpener(open func(schema.ExecQuerier) (migrate.Driver, error)) Opener {
return OpenerFunc(func(_ context.Context, u *url.URL) (*Client, error) {
v, ok := drivers.Load(u.Scheme)
if !ok {
return nil, fmt.Errorf("sql/sqlclient: unexpected missing opener %q", u.Scheme)
}
drv := v.(*driver)
ur := drv.parser.ParseURL(u)
db, err := sql.Open(drv.name, ur.DSN)
if err != nil {
return nil, err
}
mdr, err := open(db)
if err != nil {
if cerr := db.Close(); cerr != nil {
err = fmt.Errorf("%w: %v", err, cerr)
}
return nil, err
}
return &Client{
Name: drv.name,
DB: db,
URL: ur,
Driver: mdr,
openDriver: open,
openTx: drv.txOpener,
}, nil
})
}
type (
// Tx wraps sql.Tx with optional custom Commit and Rollback functions.
Tx struct {
*sql.Tx
CommitFn func() error // override default commit behavior
RollbackFn func() error // override default rollback behavior
}
// TxOpener opens a transaction with optional closer.
TxOpener func(context.Context, *sql.DB, *sql.TxOptions) (*Tx, error)
)
// Commit the transaction.
func (tx *Tx) Commit() error {
fn := tx.CommitFn
if fn == nil {
fn = tx.Tx.Commit
}
return fn()
}
// Rollback the transaction.
func (tx *Tx) Rollback() error {
fn := tx.RollbackFn
if fn == nil {
fn = tx.Tx.Rollback
}
return fn()
}
// RegisterTxOpener allows registering a custom transaction opener with an optional close function.
func RegisterTxOpener(open TxOpener) RegisterOption {
return func(opts *registerOptions) {
opts.txOpener = open
}
}
// Register registers a client Opener (i.e. creator) with the given name.
func Register(name string, opener Opener, opts ...RegisterOption) {
if opener == nil {
panic("sql/sqlclient: Register opener is nil")
}
opt := ®isterOptions{
// Default URL parser uses the URL as the DSN.
parser: URLParserFunc(func(u *url.URL) *URL { return &URL{URL: u, DSN: u.String()} }),
}
for i := range opts {
opts[i](opt)
}
if opt.codec != nil {
f := opener
opener = OpenerFunc(func(ctx context.Context, u *url.URL) (*Client, error) {
c, err := f.Open(ctx, u)
if err != nil {
return nil, err
}
c.Marshaler, c.Evaluator = opt.codec, opt.codec
return c, nil
})
}
// If there was a driver opener registered by a call to RegisterDriverOpener, it has precedence.
if opt.openDriver != nil {
f := opener
opener = OpenerFunc(func(ctx context.Context, u *url.URL) (*Client, error) {
c, err := f.Open(ctx, u)
if err != nil {
return nil, err
}
c.openDriver = opt.openDriver
return c, err
})
}
drv := &driver{Opener: opener, name: name, parser: opt.parser, txOpener: opt.txOpener}
for _, f := range append(opt.flavours, name) {
if _, ok := drivers.Load(f); ok {
panic("sql/sqlclient: Register called twice for " + f)
}
drivers.Store(f, drv)
}
}
atlas-0.7.2/sql/sqlclient/client_test.go 0000664 0000000 0000000 00000007645 14314555116 0020306 0 ustar 00root root 0000000 0000000 // Copyright 2021-present The Atlas Authors. All rights reserved.
// This source code is licensed under the Apache 2.0 license found
// in the LICENSE file in the root directory of this source tree.
package sqlclient_test
import (
"context"
"database/sql"
"net/url"
"testing"
"ariga.io/atlas/sql/migrate"
"ariga.io/atlas/sql/schema"
"github.com/DATA-DOG/go-sqlmock"
"github.com/stretchr/testify/require"
"ariga.io/atlas/sql/sqlclient"
)
func TestRegisterOpen(t *testing.T) {
c := &sqlclient.Client{}
sqlclient.Register(
"mysql",
sqlclient.OpenerFunc(func(ctx context.Context, url *url.URL) (*sqlclient.Client, error) {
return c, nil
}),
sqlclient.RegisterFlavours("maria"),
sqlclient.RegisterURLParser(sqlclient.URLParserFunc(func(u *url.URL) *sqlclient.URL {
return &sqlclient.URL{URL: u, DSN: "dsn", Schema: "schema"}
})),
)
require.PanicsWithValue(
t,
"sql/sqlclient: Register opener is nil",
func() { sqlclient.Register("mysql", nil) },
)
require.PanicsWithValue(
t,
"sql/sqlclient: Register called twice for mysql",
func() {
sqlclient.Register("mysql", sqlclient.OpenerFunc(func(ctx context.Context, url *url.URL) (*sqlclient.Client, error) {
return c, nil
}))
},
)
c1, err := sqlclient.Open(context.Background(), "mysql://:3306")
require.NoError(t, err)
require.True(t, c == c1)
require.Equal(t, "dsn", c.URL.DSN)
require.Equal(t, "schema", c.URL.Schema)
c1, err = sqlclient.Open(context.Background(), "maria://:3306")
require.NoError(t, err)
require.True(t, c == c1)
require.Equal(t, "dsn", c.URL.DSN)
require.Equal(t, "schema", c.URL.Schema)
c1, err = sqlclient.Open(context.Background(), "postgres://:3306")
require.EqualError(t, err, `sql/sqlclient: no opener was register with name "postgres"`)
}
func TestClient_AddClosers(t *testing.T) {
var (
i int
c = &sqlclient.Client{DB: sql.OpenDB(nil)}
f = closerFunc(func() error { i++; return nil })
)
c.AddClosers(f, f, f)
require.NoError(t, c.Close())
require.Equal(t, 3, i)
}
type closerFunc func() error
func (f closerFunc) Close() error { return f() }
func TestClient_Tx(t *testing.T) {
db, mock, err := sqlmock.New()
require.NoError(t, err)
defer db.Close()
const stmt = "create database `test`"
mock.ExpectBegin()
mock.ExpectExec(stmt).WillReturnResult(sqlmock.NewResult(0, 1))
mock.ExpectCommit()
mock.ExpectBegin()
mock.ExpectExec(stmt).WillReturnResult(sqlmock.NewResult(0, 1))
mock.ExpectRollback()
var cC, rC bool
sqlclient.Register(
"tx",
sqlclient.OpenerFunc(func(context.Context, *url.URL) (*sqlclient.Client, error) {
return &sqlclient.Client{Name: "tx", DB: db, Driver: &mockDriver{db: db}}, nil
}),
sqlclient.RegisterDriverOpener(func(db schema.ExecQuerier) (migrate.Driver, error) {
return &mockDriver{db: db}, nil
}),
sqlclient.RegisterTxOpener(func(ctx context.Context, db *sql.DB, opts *sql.TxOptions) (*sqlclient.Tx, error) {
tx, err := db.BeginTx(ctx, opts)
require.NoError(t, err)
return &sqlclient.Tx{
Tx: tx,
CommitFn: func() error {
cC = true
return tx.Commit()
},
RollbackFn: func() error {
rC = true
return tx.Rollback()
},
}, nil
}),
)
c, err := sqlclient.Open(context.Background(), "tx://")
require.NoError(t, err)
// Commit works.
tx, err := c.Tx(context.Background(), nil)
require.NoError(t, err)
_, err = tx.ExecContext(context.Background(), stmt)
require.NoError(t, err)
require.NoError(t, tx.Commit())
require.True(t, cC)
// Rollback works as well.
tx, err = c.Tx(context.Background(), nil)
require.NoError(t, err)
_, err = tx.ExecContext(context.Background(), stmt)
require.NoError(t, err)
require.NoError(t, tx.Rollback())
require.True(t, rC)
require.NoError(t, mock.ExpectationsWereMet())
}
type mockDriver struct {
migrate.Driver
db schema.ExecQuerier
}
func (m *mockDriver) ExecContext(ctx context.Context, query string, args ...any) (sql.Result, error) {
return m.db.ExecContext(ctx, query, args...)
}
atlas-0.7.2/sql/sqlite/ 0000775 0000000 0000000 00000000000 14314555116 0014731 5 ustar 00root root 0000000 0000000 atlas-0.7.2/sql/sqlite/convert.go 0000664 0000000 0000000 00000006135 14314555116 0016745 0 ustar 00root root 0000000 0000000 // Copyright 2021-present The Atlas Authors. All rights reserved.
// This source code is licensed under the Apache 2.0 license found
// in the LICENSE file in the root directory of this source tree.
package sqlite
import (
"fmt"
"strconv"
"strings"
"ariga.io/atlas/sql/schema"
)
// FormatType converts types to one format. A lowered format.
// This is due to SQLite flexibility to allow any data types
// and use a set of rules to define the type affinity.
// See: https://www.sqlite.org/datatype3.html
func FormatType(t schema.Type) (string, error) {
var f string
switch t := t.(type) {
case *schema.BoolType:
f = strings.ToLower(t.T)
case *schema.BinaryType:
f = strings.ToLower(t.T)
case *schema.EnumType:
f = t.T
case *schema.IntegerType:
f = strings.ToLower(t.T)
case *schema.StringType:
f = strings.ToLower(t.T)
case *schema.TimeType:
f = strings.ToLower(t.T)
case *schema.FloatType:
f = strings.ToLower(t.T)
case *schema.DecimalType:
f = strings.ToLower(t.T)
case *schema.JSONType:
f = strings.ToLower(t.T)
case *schema.SpatialType:
f = strings.ToLower(t.T)
case *UUIDType:
f = strings.ToLower(t.T)
case *schema.UnsupportedType:
return "", fmt.Errorf("sqlite: unsupported type: %q", t.T)
default:
return "", fmt.Errorf("sqlite: invalid schema type: %T", t)
}
return f, nil
}
// ParseType returns the schema.Type value represented by the given raw type.
// It is expected to be one of the types in https://www.sqlite.org/datatypes.html,
// or some of the common types used by ORMs like Ent.
func ParseType(c string) (schema.Type, error) {
// A datatype may be zero or more names.
if c == "" {
return &schema.UnsupportedType{}, nil
}
parts := columnParts(c)
switch t := parts[0]; t {
case "bool", "boolean":
return &schema.BoolType{T: t}, nil
case "blob":
return &schema.BinaryType{T: t}, nil
case "int2", "int8", "int", "integer", "tinyint", "smallint", "mediumint", "bigint", "unsigned big int":
// All integer types have the same "type affinity".
return &schema.IntegerType{T: t}, nil
case "real", "double", "double precision", "float":
return &schema.FloatType{T: t}, nil
case "numeric", "decimal":
ct := &schema.DecimalType{T: t}
if len(parts) > 1 {
p, err := strconv.ParseInt(parts[1], 10, 64)
if err != nil {
return nil, fmt.Errorf("parse precision %q", parts[1])
}
ct.Precision = int(p)
}
if len(parts) > 2 {
s, err := strconv.ParseInt(parts[2], 10, 64)
if err != nil {
return nil, fmt.Errorf("parse scale %q", parts[1])
}
ct.Scale = int(s)
}
return ct, nil
case "char", "character", "varchar", "varying character", "nchar", "native character", "nvarchar", "text", "clob":
ct := &schema.StringType{T: t}
if len(parts) > 1 {
p, err := strconv.ParseInt(parts[1], 10, 64)
if err != nil {
return nil, fmt.Errorf("parse size %q", parts[1])
}
ct.Size = int(p)
}
return ct, nil
case "json":
return &schema.JSONType{T: t}, nil
case "date", "datetime", "time", "timestamp":
return &schema.TimeType{T: t}, nil
case "uuid":
return &UUIDType{T: t}, nil
default:
return &schema.UnsupportedType{T: t}, nil
}
}
atlas-0.7.2/sql/sqlite/diff.go 0000664 0000000 0000000 00000012403 14314555116 0016170 0 ustar 00root root 0000000 0000000 // Copyright 2021-present The Atlas Authors. All rights reserved.
// This source code is licensed under the Apache 2.0 license found
// in the LICENSE file in the root directory of this source tree.
package sqlite
import (
"fmt"
"reflect"
"strconv"
"strings"
"ariga.io/atlas/sql/internal/sqlx"
"ariga.io/atlas/sql/schema"
)
// A Diff provides a SQLite implementation for sqlx.DiffDriver.
type Diff struct{}
// SchemaAttrDiff returns a changeset for migrating schema attributes from one state to the other.
func (d *Diff) SchemaAttrDiff(_, _ *schema.Schema) []schema.Change {
// No special schema attribute diffing for SQLite.
return nil
}
// TableAttrDiff returns a changeset for migrating table attributes from one state to the other.
func (d *Diff) TableAttrDiff(from, to *schema.Table) ([]schema.Change, error) {
var changes []schema.Change
switch {
case sqlx.Has(from.Attrs, &WithoutRowID{}) && !sqlx.Has(to.Attrs, &WithoutRowID{}):
changes = append(changes, &schema.DropAttr{
A: &WithoutRowID{},
})
case !sqlx.Has(from.Attrs, &WithoutRowID{}) && sqlx.Has(to.Attrs, &WithoutRowID{}):
changes = append(changes, &schema.AddAttr{
A: &WithoutRowID{},
})
}
return append(changes, sqlx.CheckDiff(from, to)...), nil
}
// ColumnChange returns the schema changes (if any) for migrating one column to the other.
func (d *Diff) ColumnChange(_ *schema.Table, from, to *schema.Column) (schema.ChangeKind, error) {
change := sqlx.CommentChange(from.Attrs, to.Attrs)
if from.Type.Null != to.Type.Null {
change |= schema.ChangeNull
}
changed, err := d.typeChanged(from, to)
if err != nil {
return schema.NoChange, err
}
if changed {
change |= schema.ChangeType
}
if changed := d.defaultChanged(from, to); changed {
change |= schema.ChangeDefault
}
if d.generatedChanged(from, to) {
change |= schema.ChangeGenerated
}
return change, nil
}
// typeChanged reports if the column type was changed.
func (d *Diff) typeChanged(from, to *schema.Column) (bool, error) {
fromT, toT := from.Type.Type, to.Type.Type
if fromT == nil || toT == nil {
return false, fmt.Errorf("sqlite: missing type information for column %q", from.Name)
}
// Types are mismatched if they do not have the same "type affinity".
return reflect.TypeOf(fromT) != reflect.TypeOf(toT), nil
}
// defaultChanged reports if the default value of a column was changed.
func (d *Diff) defaultChanged(from, to *schema.Column) bool {
d1, ok1 := sqlx.DefaultValue(from)
d2, ok2 := sqlx.DefaultValue(to)
if ok1 != ok2 {
return true
}
if d1 == d2 {
return false
}
x1, err1 := sqlx.Unquote(d1)
x2, err2 := sqlx.Unquote(d2)
return err1 != nil || err2 != nil || x1 != x2
}
// generatedChanged reports if the generated expression of a column was changed.
func (*Diff) generatedChanged(from, to *schema.Column) bool {
var (
fromX, toX schema.GeneratedExpr
fromHas, toHas = sqlx.Has(from.Attrs, &fromX), sqlx.Has(to.Attrs, &toX)
)
return fromHas != toHas || fromHas && (sqlx.MayWrap(fromX.Expr) != sqlx.MayWrap(toX.Expr) || storedOrVirtual(fromX.Type) != storedOrVirtual(toX.Type))
}
// IsGeneratedIndexName reports if the index name was generated by the database.
// See: https://github.com/sqlite/sqlite/blob/e937df8/src/build.c#L3583.
func (d *Diff) IsGeneratedIndexName(t *schema.Table, idx *schema.Index) bool {
p := fmt.Sprintf("sqlite_autoindex_%s_", t.Name)
if !strings.HasPrefix(idx.Name, p) {
return false
}
i, err := strconv.ParseInt(strings.TrimPrefix(idx.Name, p), 10, 64)
return err == nil && i > 0
}
// IndexAttrChanged reports if the index attributes were changed.
func (*Diff) IndexAttrChanged(from, to []schema.Attr) bool {
var p1, p2 IndexPredicate
return sqlx.Has(from, &p1) != sqlx.Has(to, &p2) || (p1.P != p2.P && p1.P != sqlx.MayWrap(p2.P))
}
// IndexPartAttrChanged reports if the index-part attributes were changed.
func (*Diff) IndexPartAttrChanged(_, _ *schema.IndexPart) bool {
return false
}
// ReferenceChanged reports if the foreign key referential action was changed.
func (*Diff) ReferenceChanged(from, to schema.ReferenceOption) bool {
// According to SQLite, if an action is not explicitly
// specified, it defaults to "NO ACTION".
if from == "" {
from = schema.NoAction
}
if to == "" {
to = schema.NoAction
}
return from != to
}
// Normalize implements the sqlx.Normalizer interface.
func (d *Diff) Normalize(from, to *schema.Table) error {
used := make([]bool, len(to.ForeignKeys))
// In SQLite, there is no easy way to get the foreign-key constraint
// name, except for parsing the CREATE statement. Therefore, we check
// if there is a foreign-key with identical properties.
for _, fk1 := range from.ForeignKeys {
for i, fk2 := range to.ForeignKeys {
if used[i] {
continue
}
if fk2.Symbol == fk1.Symbol && !isNumber(fk1.Symbol) || sameFK(fk1, fk2) {
fk1.Symbol = fk2.Symbol
used[i] = true
}
}
}
return nil
}
func sameFK(fk1, fk2 *schema.ForeignKey) bool {
if fk1.Table.Name != fk2.Table.Name || fk1.RefTable.Name != fk2.RefTable.Name ||
len(fk1.Columns) != len(fk2.Columns) || len(fk1.RefColumns) != len(fk2.RefColumns) {
return false
}
for i, c1 := range fk1.Columns {
if c1.Name != fk2.Columns[i].Name {
return false
}
}
for i, c1 := range fk1.RefColumns {
if c1.Name != fk2.RefColumns[i].Name {
return false
}
}
return true
}
atlas-0.7.2/sql/sqlite/diff_test.go 0000664 0000000 0000000 00000025410 14314555116 0017231 0 ustar 00root root 0000000 0000000 // Copyright 2021-present The Atlas Authors. All rights reserved.
// This source code is licensed under the Apache 2.0 license found
// in the LICENSE file in the root directory of this source tree.
package sqlite
import (
"testing"
"ariga.io/atlas/sql/schema"
"github.com/DATA-DOG/go-sqlmock"
"github.com/stretchr/testify/require"
)
func TestDiff_TableDiff(t *testing.T) {
type testcase struct {
name string
from, to *schema.Table
wantChanges []schema.Change
wantErr bool
}
tests := []testcase{
{
name: "no changes",
from: &schema.Table{Name: "users", Schema: &schema.Schema{Name: "public"}},
to: &schema.Table{Name: "users"},
},
{
name: "change primary key",
from: func() *schema.Table {
t := &schema.Table{Name: "users", Schema: &schema.Schema{Name: "public"}, Columns: []*schema.Column{{Name: "id", Type: &schema.ColumnType{Raw: "int", Type: &schema.IntegerType{T: "int"}}}}}
t.PrimaryKey = &schema.Index{
Parts: []*schema.IndexPart{{C: t.Columns[0]}},
}
return t
}(),
to: &schema.Table{Name: "users"},
wantErr: true,
},
{
name: "add attr",
from: &schema.Table{Name: "t1", Schema: &schema.Schema{Name: "public"}},
to: &schema.Table{Name: "t1", Attrs: []schema.Attr{&WithoutRowID{}}},
wantChanges: []schema.Change{
&schema.AddAttr{
A: &WithoutRowID{},
},
},
},
{
name: "drop attr",
from: &schema.Table{Name: "t1", Attrs: []schema.Attr{&WithoutRowID{}}},
to: &schema.Table{Name: "t1"},
wantChanges: []schema.Change{
&schema.DropAttr{
A: &WithoutRowID{},
},
},
},
{
name: "add check",
from: &schema.Table{Name: "t1"},
to: &schema.Table{Name: "t1", Attrs: []schema.Attr{&schema.Check{Name: "t1_c1_check", Expr: "(c1 > 1)"}}},
wantChanges: []schema.Change{
&schema.AddCheck{
C: &schema.Check{Name: "t1_c1_check", Expr: "(c1 > 1)"},
},
},
},
{
name: "drop check",
from: &schema.Table{Name: "t1", Attrs: []schema.Attr{&schema.Check{Name: "t1_c1_check", Expr: "(c1 > 1)"}}},
to: &schema.Table{Name: "t1"},
wantChanges: []schema.Change{
&schema.DropCheck{
C: &schema.Check{Name: "t1_c1_check", Expr: "(c1 > 1)"},
},
},
},
{
name: "find check by expr",
from: &schema.Table{
Name: "t1",
Attrs: []schema.Attr{
&schema.Check{Name: "t1_c1_check", Expr: "(c1 > 1)"},
&schema.Check{Expr: "(d1 > 1)"},
},
},
to: &schema.Table{
Name: "t1",
Attrs: []schema.Attr{
&schema.Check{Expr: "(c1 > 1)"},
&schema.Check{Name: "add_name_to_check", Expr: "(d1 > 1)"},
},
},
},
func() testcase {
var (
from = &schema.Table{
Name: "t1",
Schema: &schema.Schema{
Name: "public",
},
Columns: []*schema.Column{
{Name: "c1", Type: &schema.ColumnType{Raw: "json", Type: &schema.JSONType{T: "json"}}},
{Name: "c2", Type: &schema.ColumnType{Raw: "int8", Type: &schema.IntegerType{T: "int8"}}},
},
}
to = &schema.Table{
Name: "t1",
Columns: []*schema.Column{
{
Name: "c1",
Type: &schema.ColumnType{Raw: "json", Type: &schema.JSONType{T: "json"}, Null: true},
Default: &schema.RawExpr{X: "{}"},
Attrs: []schema.Attr{&schema.Comment{Text: "json comment"}},
},
{Name: "c3", Type: &schema.ColumnType{Raw: "int", Type: &schema.IntegerType{T: "int"}}},
},
}
)
return testcase{
name: "columns",
from: from,
to: to,
wantChanges: []schema.Change{
&schema.ModifyColumn{
From: from.Columns[0],
To: to.Columns[0],
Change: schema.ChangeNull | schema.ChangeComment | schema.ChangeDefault,
},
&schema.DropColumn{C: from.Columns[1]},
&schema.AddColumn{C: to.Columns[1]},
},
}
}(),
func() testcase {
var (
s = schema.New("public")
from = schema.NewTable("t1").
SetSchema(s).
AddColumns(
schema.NewIntColumn("c1", "int"),
schema.NewIntColumn("c2", "int").
SetGeneratedExpr(&schema.GeneratedExpr{Expr: "1", Type: "STORED"}),
schema.NewIntColumn("c3", "int").
SetGeneratedExpr(&schema.GeneratedExpr{Expr: "1"}),
schema.NewIntColumn("c4", "int").
SetGeneratedExpr(&schema.GeneratedExpr{Expr: "1", Type: "VIRTUAL"}),
)
to = schema.NewTable("t1").
SetSchema(s).
AddColumns(
// Add generated expression.
schema.NewIntColumn("c1", "int").
SetGeneratedExpr(&schema.GeneratedExpr{Expr: "1", Type: "STORED"}),
// Drop generated expression.
schema.NewIntColumn("c2", "int"),
// Modify generated expression.
schema.NewIntColumn("c3", "int").
SetGeneratedExpr(&schema.GeneratedExpr{Expr: "2"}),
// No change.
schema.NewIntColumn("c4", "int").
SetGeneratedExpr(&schema.GeneratedExpr{Expr: "1"}),
)
)
return testcase{
name: "modify column generated",
from: from,
to: to,
wantChanges: []schema.Change{
&schema.ModifyColumn{From: from.Columns[0], To: to.Columns[0], Change: schema.ChangeGenerated},
&schema.ModifyColumn{From: from.Columns[1], To: to.Columns[1], Change: schema.ChangeGenerated},
&schema.ModifyColumn{From: from.Columns[2], To: to.Columns[2], Change: schema.ChangeGenerated},
},
}
}(),
func() testcase {
var (
from = &schema.Table{
Name: "t1",
Schema: &schema.Schema{
Name: "public",
},
Columns: []*schema.Column{
{Name: "c1", Type: &schema.ColumnType{Raw: "json", Type: &schema.JSONType{T: "json"}}},
{Name: "c2", Type: &schema.ColumnType{Raw: "int8", Type: &schema.IntegerType{T: "int8"}}},
{Name: "c3", Type: &schema.ColumnType{Raw: "int", Type: &schema.IntegerType{T: "int"}}},
},
}
to = &schema.Table{
Name: "t1",
Schema: &schema.Schema{
Name: "public",
},
Columns: []*schema.Column{
{Name: "c1", Type: &schema.ColumnType{Raw: "json", Type: &schema.JSONType{T: "json"}}},
{Name: "c2", Type: &schema.ColumnType{Raw: "int8", Type: &schema.IntegerType{T: "int8"}}},
{Name: "c3", Type: &schema.ColumnType{Raw: "int", Type: &schema.IntegerType{T: "int"}}},
},
}
)
from.Indexes = []*schema.Index{
{Name: "c1_index", Unique: true, Table: from, Parts: []*schema.IndexPart{{SeqNo: 1, C: from.Columns[0]}}},
{Name: "c2_unique", Unique: true, Table: from, Parts: []*schema.IndexPart{{SeqNo: 1, C: from.Columns[1]}}},
{Name: "c3_predicate", Table: from, Parts: []*schema.IndexPart{{SeqNo: 1, C: from.Columns[1]}}},
{Name: "c3_desc", Table: from, Parts: []*schema.IndexPart{{SeqNo: 1, C: to.Columns[1]}}},
{Name: "c4_predicate", Table: from, Parts: []*schema.IndexPart{{SeqNo: 1, C: from.Columns[1]}}, Attrs: []schema.Attr{&IndexPredicate{P: "(c4 <> NULL)"}}},
}
to.Indexes = []*schema.Index{
{Name: "c1_index", Table: from, Parts: []*schema.IndexPart{{SeqNo: 1, C: from.Columns[0]}}},
{Name: "c3_unique", Unique: true, Table: from, Parts: []*schema.IndexPart{{SeqNo: 1, C: to.Columns[1]}}},
{Name: "c3_predicate", Table: from, Parts: []*schema.IndexPart{{SeqNo: 1, C: from.Columns[1]}}, Attrs: []schema.Attr{&IndexPredicate{P: "c3 <> NULL"}}},
{Name: "c3_desc", Table: from, Parts: []*schema.IndexPart{{SeqNo: 1, Desc: true, C: to.Columns[1]}}},
{Name: "c4_predicate", Table: from, Parts: []*schema.IndexPart{{SeqNo: 1, C: from.Columns[1]}}, Attrs: []schema.Attr{&IndexPredicate{P: "c4 <> NULL"}}},
}
return testcase{
name: "indexes",
from: from,
to: to,
wantChanges: []schema.Change{
&schema.ModifyIndex{From: from.Indexes[0], To: to.Indexes[0], Change: schema.ChangeUnique},
&schema.DropIndex{I: from.Indexes[1]},
&schema.ModifyIndex{From: from.Indexes[2], To: to.Indexes[2], Change: schema.ChangeAttr},
&schema.ModifyIndex{From: from.Indexes[3], To: to.Indexes[3], Change: schema.ChangeParts},
&schema.AddIndex{I: to.Indexes[1]},
},
}
}(),
func() testcase {
var (
ref = &schema.Table{
Name: "t2",
Schema: &schema.Schema{
Name: "public",
},
Columns: []*schema.Column{
{Name: "id", Type: &schema.ColumnType{Raw: "int", Type: &schema.IntegerType{T: "int"}}},
{Name: "ref_id", Type: &schema.ColumnType{Raw: "int", Type: &schema.IntegerType{T: "int"}}},
},
}
from = &schema.Table{
Name: "t1",
Schema: &schema.Schema{
Name: "public",
},
Columns: []*schema.Column{
{Name: "t2_id", Type: &schema.ColumnType{Raw: "int", Type: &schema.IntegerType{T: "int"}}},
},
}
to = &schema.Table{
Name: "t1",
Schema: &schema.Schema{
Name: "public",
},
Columns: []*schema.Column{
{Name: "t2_id", Type: &schema.ColumnType{Raw: "int", Type: &schema.IntegerType{T: "int"}}},
},
}
)
from.ForeignKeys = []*schema.ForeignKey{
{Symbol: "fk1", Table: to, Columns: to.Columns, RefTable: ref, RefColumns: ref.Columns[1:]},
{Symbol: "1", Table: from, Columns: from.Columns, RefTable: ref, RefColumns: ref.Columns[:1]},
}
to.ForeignKeys = []*schema.ForeignKey{
{Symbol: "fk1", Table: to, Columns: to.Columns, RefTable: ref, RefColumns: ref.Columns[:1]},
// The below "constraint" is identical to "0" above, therefore, the differ does not report a change.
{Symbol: "constraint", Table: from, Columns: from.Columns, RefTable: ref, RefColumns: ref.Columns[:1]},
}
return testcase{
name: "foreign-keys",
from: from,
to: to,
wantChanges: []schema.Change{
&schema.ModifyForeignKey{
From: from.ForeignKeys[0],
To: to.ForeignKeys[0],
Change: schema.ChangeRefColumn,
},
},
}
}(),
}
for _, tt := range tests {
db, m, err := sqlmock.New()
require.NoError(t, err)
mock{m}.systemVars("3.36.0")
drv, err := Open(db)
require.NoError(t, err)
t.Run(tt.name, func(t *testing.T) {
changes, err := drv.TableDiff(tt.from, tt.to)
require.Equal(t, tt.wantErr, err != nil, err)
require.EqualValues(t, tt.wantChanges, changes)
})
}
}
func TestDiff_SchemaDiff(t *testing.T) {
db, m, err := sqlmock.New()
require.NoError(t, err)
mock{m}.systemVars("3.36.0")
drv, err := Open(db)
require.NoError(t, err)
from := &schema.Schema{
Tables: []*schema.Table{
{Name: "users"},
{Name: "pets"},
},
}
to := &schema.Schema{
Tables: []*schema.Table{
{
Name: "users",
Columns: []*schema.Column{
{Name: "t2_id", Type: &schema.ColumnType{Raw: "int", Type: &schema.IntegerType{T: "int"}}},
},
},
{Name: "groups"},
},
}
from.Tables[0].Schema = from
from.Tables[1].Schema = from
changes, err := drv.SchemaDiff(from, to)
require.NoError(t, err)
require.EqualValues(t, []schema.Change{
&schema.ModifyTable{T: to.Tables[0], Changes: []schema.Change{&schema.AddColumn{C: to.Tables[0].Columns[0]}}},
&schema.DropTable{T: from.Tables[1]},
&schema.AddTable{T: to.Tables[1]},
}, changes)
}
atlas-0.7.2/sql/sqlite/driver.go 0000664 0000000 0000000 00000023070 14314555116 0016555 0 ustar 00root root 0000000 0000000 // Copyright 2021-present The Atlas Authors. All rights reserved.
// This source code is licensed under the Apache 2.0 license found
// in the LICENSE file in the root directory of this source tree.
package sqlite
import (
"context"
"database/sql"
"errors"
"fmt"
"net/url"
"os"
"path/filepath"
"strconv"
"strings"
"time"
"ariga.io/atlas/sql/internal/sqlx"
"ariga.io/atlas/sql/migrate"
"ariga.io/atlas/sql/schema"
"ariga.io/atlas/sql/sqlclient"
)
type (
// Driver represents a SQLite driver for introspecting database schemas,
// generating diff between schema elements and apply migrations changes.
Driver struct {
conn
schema.Differ
schema.Inspector
migrate.PlanApplier
}
// database connection and its information.
conn struct {
schema.ExecQuerier
// System variables that are set on `Open`.
version string
collations []string
}
)
// DriverName holds the name used for registration.
const DriverName = "sqlite3"
func init() {
sqlclient.Register(
DriverName,
sqlclient.DriverOpener(Open),
sqlclient.RegisterTxOpener(OpenTx),
sqlclient.RegisterCodec(MarshalHCL, EvalHCL),
sqlclient.RegisterFlavours("sqlite"),
sqlclient.RegisterURLParser(sqlclient.URLParserFunc(func(u *url.URL) *sqlclient.URL {
uc := &sqlclient.URL{URL: u, DSN: strings.TrimPrefix(u.String(), u.Scheme+"://"), Schema: mainFile}
if mode := u.Query().Get("mode"); mode == "memory" {
// The "file:" prefix is mandatory for memory modes.
uc.DSN = "file:" + uc.DSN
}
return uc
})),
)
}
// Open opens a new SQLite driver.
func Open(db schema.ExecQuerier) (migrate.Driver, error) {
var (
c = conn{ExecQuerier: db}
ctx = context.Background()
)
rows, err := db.QueryContext(ctx, "SELECT sqlite_version()")
if err != nil {
return nil, fmt.Errorf("sqlite: query version pragma: %w", err)
}
if err := sqlx.ScanOne(rows, &c.version); err != nil {
return nil, fmt.Errorf("sqlite: scan version pragma: %w", err)
}
if rows, err = db.QueryContext(ctx, "SELECT name FROM pragma_collation_list()"); err != nil {
return nil, fmt.Errorf("sqlite: query collation_list pragma: %w", err)
}
if c.collations, err = sqlx.ScanStrings(rows); err != nil {
return nil, fmt.Errorf("sqlite: scanning database collations: %w", err)
}
return &Driver{
conn: c,
Differ: &sqlx.Diff{DiffDriver: &Diff{}},
Inspector: &inspect{c},
PlanApplier: &planApply{c},
}, nil
}
// Snapshot implements migrate.Snapshoter.
func (d *Driver) Snapshot(ctx context.Context) (migrate.RestoreFunc, error) {
r, err := d.InspectRealm(ctx, nil)
if err != nil {
return nil, err
}
if !(r == nil || (len(r.Schemas) == 1 && r.Schemas[0].Name == mainFile && len(r.Schemas[0].Tables) == 0)) {
return nil, migrate.NotCleanError{Reason: fmt.Sprintf("found table %q", r.Schemas[0].Tables[0].Name)}
}
return func(ctx context.Context) error {
for _, stmt := range []string{
"PRAGMA writable_schema = 1;",
"DELETE FROM sqlite_master WHERE type IN ('table', 'index', 'trigger');",
"PRAGMA writable_schema = 0;",
"VACUUM;",
} {
if _, err := d.ExecContext(ctx, stmt); err != nil {
return err
}
}
return nil
}, nil
}
// CheckClean implements migrate.CleanChecker.
func (d *Driver) CheckClean(ctx context.Context, revT *migrate.TableIdent) error {
r, err := d.InspectRealm(ctx, nil)
if err != nil {
return err
}
switch n := len(r.Schemas); {
case n > 1:
return migrate.NotCleanError{Reason: fmt.Sprintf("found multiple schemas: %d", len(r.Schemas))}
case n == 1 && r.Schemas[0].Name != mainFile:
return migrate.NotCleanError{Reason: fmt.Sprintf("found schema %q", r.Schemas[0].Name)}
case n == 1 && len(r.Schemas[0].Tables) > 1:
return migrate.NotCleanError{Reason: fmt.Sprintf("found multiple tables: %d", len(r.Schemas[0].Tables))}
case n == 1 && len(r.Schemas[0].Tables) == 1 && (revT == nil || r.Schemas[0].Tables[0].Name != revT.Name):
return migrate.NotCleanError{Reason: fmt.Sprintf("found table %q", r.Schemas[0].Tables[0].Name)}
}
return nil
}
// Lock implements the schema.Locker interface.
func (d *Driver) Lock(_ context.Context, name string, timeout time.Duration) (schema.UnlockFunc, error) {
path := filepath.Join(os.TempDir(), name+".lock")
c, err := os.ReadFile(path)
if errors.Is(err, os.ErrNotExist) {
return acquireLock(path, timeout)
}
if err != nil {
return nil, fmt.Errorf("sql/sqlite: reading lock dir: %w", err)
}
expires, err := strconv.ParseInt(string(c), 10, 64)
if err != nil {
return nil, fmt.Errorf("sql/sqlite: invalid lock file format: parsing expiration date: %w", err)
}
if time.Unix(0, expires).After(time.Now()) {
// Lock is still valid.
return nil, fmt.Errorf("sql/sqlite: lock on %q already taken", name)
}
return acquireLock(path, timeout)
}
func acquireLock(path string, timeout time.Duration) (schema.UnlockFunc, error) {
lock, err := os.Create(path)
if err != nil {
return nil, fmt.Errorf("sql/sqlite: creating lockfile %q: %w", path, err)
}
if _, err := lock.Write([]byte(strconv.FormatInt(time.Now().Add(timeout).UnixNano(), 10))); err != nil {
return nil, fmt.Errorf("sql/sqlite: writing to lockfile %q: %w", path, err)
}
defer lock.Close()
return func() error { return os.Remove(path) }, nil
}
type violation struct {
tbl, ref string
row, index int
}
// OpenTx opens a transaction. If foreign keys are enabled, it disables them, checks for constraint violations,
// opens the transaction and before committing ensures no new violations have been introduced by whatever Atlas was
// doing.
func OpenTx(ctx context.Context, db *sql.DB, opts *sql.TxOptions) (*sqlclient.Tx, error) {
var on sql.NullBool
if err := db.QueryRowContext(ctx, "PRAGMA foreign_keys").Scan(&on); err != nil {
return nil, fmt.Errorf("sql/sqlite: querying 'foreign_keys' pragma: %w", err)
}
// Disable the foreign_keys pragma in case it is enabled, and
// toggle it back after transaction is committed or rolled back.
if on.Bool {
_, err := db.ExecContext(ctx, "PRAGMA foreign_keys = off")
if err != nil {
return nil, fmt.Errorf("sql/sqlite: set 'foreign_keys = off': %w", err)
}
}
tx, err := db.BeginTx(ctx, opts)
if err != nil {
return nil, err
}
cm, err := CommitFunc(ctx, db, tx, on.Bool)
if err != nil {
return nil, err
}
return &sqlclient.Tx{
Tx: tx,
CommitFn: cm,
RollbackFn: RollbackFunc(ctx, db, tx, on.Bool),
}, nil
}
// Tx wraps schema.ExecQuerier with the transaction methods.
type Tx interface {
schema.ExecQuerier
Commit() error
Rollback() error
}
// CommitFunc takes a transaction and ensures to toggle foreign keys back on after tx.Commit is called.
func CommitFunc(ctx context.Context, db schema.ExecQuerier, tx Tx, on bool) (func() error, error) {
var (
before []violation
err error
)
if on {
before, err = violations(ctx, tx)
if err != nil {
return nil, err
}
}
return func() error {
if on {
after, err := violations(ctx, tx)
if err != nil {
if err2 := tx.Rollback(); err2 != nil {
err = fmt.Errorf("%v: %w", err2, err)
}
return enableFK(ctx, db, on, err)
}
if vs := violationsDiff(before, after); len(vs) > 0 {
err := fmt.Errorf("sql/sqlite: foreign key mismatch: %+v", vs)
if err2 := tx.Rollback(); err2 != nil {
err = fmt.Errorf("%v: %w", err2, err)
}
return enableFK(ctx, db, on, err)
}
}
return enableFK(ctx, db, on, tx.Commit())
}, nil
}
// RollbackFunc takes a transaction and ensures to toggle foreign keys back on after tx.Rollback is called.
func RollbackFunc(ctx context.Context, db schema.ExecQuerier, tx Tx, on bool) func() error {
return func() error {
return enableFK(ctx, db, on, tx.Rollback())
}
}
func enableFK(ctx context.Context, db schema.ExecQuerier, do bool, err error) error {
if do {
// Re-enable foreign key checks if they were enabled before.
if _, err2 := db.ExecContext(ctx, "PRAGMA foreign_keys = on"); err2 != nil {
err2 = fmt.Errorf("sql/sqlite: set 'foreign_keys = on': %w", err2)
if err != nil {
return fmt.Errorf("%v: %w", err2, err)
}
return err2
}
}
return err
}
func violations(ctx context.Context, conn schema.ExecQuerier) ([]violation, error) {
rows, err := conn.QueryContext(ctx, "PRAGMA foreign_key_check")
if err != nil {
return nil, fmt.Errorf("sql/sqlite: querying 'foreign_key_check' pragma: %w", err)
}
defer rows.Close()
var vs []violation
for rows.Next() {
var v violation
if err := rows.Scan(&v.tbl, &v.row, &v.ref, &v.index); err != nil {
return nil, fmt.Errorf("sql/sqlite: querying 'foreign_key_check' pragma: scanning rows: %w", err)
}
vs = append(vs, v)
}
if err := rows.Err(); err != nil {
return nil, fmt.Errorf("sql/sqlite: querying 'foreign_key_check' pragma: scanning rows: %w", err)
}
return vs, nil
}
// equalViolations compares the foreign key violations before starting a transaction with the ones afterwards.
// It returns violations found in v2 that are not in v1.
func violationsDiff(v1, v2 []violation) (vs []violation) {
for _, v := range v2 {
if !contains(v1, v) {
vs = append(vs, v)
}
}
return vs
}
func contains(hs []violation, n violation) bool {
for _, v := range hs {
if v.row == n.row && v.ref == n.ref && v.index == n.index && v.tbl == n.tbl {
return true
}
}
return false
}
// SQLite standard data types as defined in its codebase and documentation.
// https://www.sqlite.org/datatype3.html
// https://github.com/sqlite/sqlite/blob/master/src/global.c
const (
TypeInteger = "integer" // SQLITE_TYPE_INTEGER
TypeReal = "real" // SQLITE_TYPE_REAL
TypeText = "text" // SQLITE_TYPE_TEXT
TypeBlob = "blob" // SQLITE_TYPE_BLOB
)
// SQLite generated columns types.
const (
virtual = "VIRTUAL"
stored = "STORED"
)
atlas-0.7.2/sql/sqlite/driver_test.go 0000664 0000000 0000000 00000005211 14314555116 0017611 0 ustar 00root root 0000000 0000000 // Copyright 2021-present The Atlas Authors. All rights reserved.
// This source code is licensed under the Apache 2.0 license found
// in the LICENSE file in the root directory of this source tree.
package sqlite
import (
"context"
"os"
"path/filepath"
"strconv"
"testing"
"time"
"ariga.io/atlas/sql/migrate"
"ariga.io/atlas/sql/schema"
"github.com/stretchr/testify/require"
)
func TestDriver_LockAcquired(t *testing.T) {
drv := &Driver{}
// Acquiring a lock does work.
unlock, err := drv.Lock(context.Background(), "lock", time.Second)
require.NoError(t, err)
require.NotNil(t, unlock)
// Acquiring a lock on the same value will fail.
_, err = drv.Lock(context.Background(), "lock", time.Second)
require.Error(t, err)
// After unlock it will succeed again.
require.NoError(t, unlock())
_, err = drv.Lock(context.Background(), "lock", time.Second)
require.NoError(t, err)
require.NotNil(t, unlock)
// Acquiring a lock on a value that has been expired works.
dir, err := os.UserCacheDir()
require.NoError(t, err)
require.NoError(t, os.WriteFile(
filepath.Join(dir, "lock.lock"),
[]byte(strconv.FormatInt(time.Now().Add(-time.Second).UnixNano(), 10)),
0666,
))
_, err = drv.Lock(context.Background(), "lock", time.Second)
// Acquiring a lock on another value works as well.
_, err = drv.Lock(context.Background(), "another", time.Second)
}
func TestDriver_CheckClean(t *testing.T) {
var (
r = schema.NewRealm()
drv = &Driver{Inspector: &mockInspector{realm: r}}
)
// Empty realm.
err := drv.CheckClean(context.Background(), nil)
require.NoError(t, err)
// Empty schema.
r.AddSchemas(schema.New("main"))
err = drv.CheckClean(context.Background(), nil)
require.NoError(t, err)
// Schema with revisions table only.
r.Schemas[0].AddTables(schema.NewTable("revisions"))
err = drv.CheckClean(context.Background(), &migrate.TableIdent{Name: "revisions"})
require.NoError(t, err)
// Unknown table.
r.Schemas[0].Tables[0].Name = "unknown"
err = drv.CheckClean(context.Background(), &migrate.TableIdent{Name: "revisions"})
require.EqualError(t, err, `sql/migrate: connected database is not clean: found table "unknown"`)
// Multiple tables.
r.Schemas[0].Tables = []*schema.Table{schema.NewTable("a"), schema.NewTable("revisions")}
err = drv.CheckClean(context.Background(), &migrate.TableIdent{Schema: "test", Name: "revisions"})
require.EqualError(t, err, `sql/migrate: connected database is not clean: found multiple tables: 2`)
}
type mockInspector struct {
schema.Inspector
realm *schema.Realm
}
func (m *mockInspector) InspectRealm(context.Context, *schema.InspectRealmOption) (*schema.Realm, error) {
return m.realm, nil
}
atlas-0.7.2/sql/sqlite/inspect.go 0000664 0000000 0000000 00000051200 14314555116 0016723 0 ustar 00root root 0000000 0000000 // Copyright 2021-present The Atlas Authors. All rights reserved.
// This source code is licensed under the Apache 2.0 license found
// in the LICENSE file in the root directory of this source tree.
package sqlite
import (
"context"
"database/sql"
"fmt"
"regexp"
"strconv"
"strings"
"unicode"
"ariga.io/atlas/sql/internal/sqlx"
"ariga.io/atlas/sql/schema"
)
// A diff provides an SQLite implementation for schema.Inspector.
type inspect struct{ conn }
var _ schema.Inspector = (*inspect)(nil)
// InspectRealm returns schema descriptions of all resources in the given realm.
func (i *inspect) InspectRealm(ctx context.Context, opts *schema.InspectRealmOption) (*schema.Realm, error) {
schemas, err := i.databases(ctx, opts)
if err != nil {
return nil, err
}
if len(schemas) > 1 {
return nil, fmt.Errorf("sqlite: multiple database files are not supported by the driver. got: %d", len(schemas))
}
if opts == nil {
opts = &schema.InspectRealmOption{}
}
r := schema.NewRealm(schemas...)
if !sqlx.ModeInspectRealm(opts).Is(schema.InspectTables) {
return sqlx.ExcludeRealm(r, opts.Exclude)
}
for _, s := range schemas {
tables, err := i.tables(ctx, nil)
if err != nil {
return nil, err
}
s.AddTables(tables...)
for _, t := range tables {
if err := i.inspectTable(ctx, t); err != nil {
return nil, err
}
}
}
sqlx.LinkSchemaTables(r.Schemas)
return sqlx.ExcludeRealm(r, opts.Exclude)
}
// InspectSchema returns schema descriptions of the tables in the given schema.
// If the schema name is empty, the "main" database is used.
func (i *inspect) InspectSchema(ctx context.Context, name string, opts *schema.InspectOptions) (*schema.Schema, error) {
if name == "" {
name = mainFile
}
schemas, err := i.databases(ctx, &schema.InspectRealmOption{
Schemas: []string{name},
})
if err != nil {
return nil, err
}
if len(schemas) == 0 {
return nil, &schema.NotExistError{
Err: fmt.Errorf("sqlite: schema %q was not found", name),
}
}
if opts == nil {
opts = &schema.InspectOptions{}
}
r := schema.NewRealm(schemas...)
if !sqlx.ModeInspectSchema(opts).Is(schema.InspectTables) {
return sqlx.ExcludeSchema(r.Schemas[0], opts.Exclude)
}
tables, err := i.tables(ctx, opts)
if err != nil {
return nil, err
}
r.Schemas[0].AddTables(tables...)
for _, t := range tables {
if err := i.inspectTable(ctx, t); err != nil {
return nil, err
}
}
sqlx.LinkSchemaTables(schemas)
return sqlx.ExcludeSchema(r.Schemas[0], opts.Exclude)
}
func (i *inspect) inspectTable(ctx context.Context, t *schema.Table) error {
if err := i.columns(ctx, t); err != nil {
return err
}
if err := i.indexes(ctx, t); err != nil {
return err
}
if err := i.fks(ctx, t); err != nil {
return err
}
if err := fillChecks(t); err != nil {
return err
}
return nil
}
// columns queries and appends the columns of the given table.
func (i *inspect) columns(ctx context.Context, t *schema.Table) error {
rows, err := i.QueryContext(ctx, fmt.Sprintf(columnsQuery, t.Name))
if err != nil {
return fmt.Errorf("sqlite: querying %q columns: %w", t.Name, err)
}
defer rows.Close()
for rows.Next() {
if err := i.addColumn(t, rows); err != nil {
return fmt.Errorf("sqlite: %w", err)
}
}
return autoinc(t)
}
// addColumn scans the current row and adds a new column from it to the table.
func (i *inspect) addColumn(t *schema.Table, rows *sql.Rows) error {
var (
nullable, primary bool
hidden sql.NullInt64
name, typ, defaults sql.NullString
err error
)
if err = rows.Scan(&name, &typ, &nullable, &defaults, &primary, &hidden); err != nil {
return err
}
c := &schema.Column{
Name: name.String,
Type: &schema.ColumnType{
Raw: typ.String,
Null: nullable,
},
}
c.Type.Type, err = ParseType(typ.String)
if err != nil {
return err
}
if defaults.Valid {
c.Default = defaultExpr(defaults.String)
}
// The hidden flag is set to 2 for VIRTUAL columns, and to
// 3 for STORED columns. See: sqlite/pragma.c#sqlite3Pragma.
if hidden.Int64 >= 2 {
if err := setGenExpr(t, c, hidden.Int64); err != nil {
return err
}
}
t.Columns = append(t.Columns, c)
if primary {
if t.PrimaryKey == nil {
t.PrimaryKey = &schema.Index{
Name: "PRIMARY",
Unique: true,
Table: t,
}
}
// Columns are ordered by the `pk` field.
t.PrimaryKey.Parts = append(t.PrimaryKey.Parts, &schema.IndexPart{
C: c,
SeqNo: len(t.PrimaryKey.Parts) + 1,
})
}
return nil
}
// indexes queries and appends the indexes of the given table.
func (i *inspect) indexes(ctx context.Context, t *schema.Table) error {
rows, err := i.QueryContext(ctx, fmt.Sprintf(indexesQuery, t.Name))
if err != nil {
return fmt.Errorf("sqlite: querying %q indexes: %w", t.Name, err)
}
if err := i.addIndexes(t, rows); err != nil {
return fmt.Errorf("sqlite: scan %q indexes: %w", t.Name, err)
}
for _, idx := range t.Indexes {
if err := i.indexInfo(ctx, t, idx); err != nil {
return err
}
}
return nil
}
// addIndexes scans the rows and adds the indexes to the table.
func (i *inspect) addIndexes(t *schema.Table, rows *sql.Rows) error {
defer rows.Close()
for rows.Next() {
var (
uniq, partial bool
name, origin, stmt sql.NullString
)
if err := rows.Scan(&name, &uniq, &origin, &partial, &stmt); err != nil {
return err
}
if origin.String == "pk" {
continue
}
idx := &schema.Index{
Name: name.String,
Unique: uniq,
Table: t,
Attrs: []schema.Attr{
&CreateStmt{S: stmt.String},
&IndexOrigin{O: origin.String},
},
}
if partial {
i := strings.Index(stmt.String, "WHERE")
if i == -1 {
return fmt.Errorf("missing partial WHERE clause in: %s", stmt.String)
}
idx.Attrs = append(idx.Attrs, &IndexPredicate{
P: strings.TrimSpace(stmt.String[i+5:]),
})
}
t.Indexes = append(t.Indexes, idx)
}
return nil
}
// A regexp to extract index parts.
var reIdxParts = regexp.MustCompile("(?i)ON\\s+[\"`]*(?:\\w+)[\"`]*\\s*\\((.+)\\)")
func (i *inspect) indexInfo(ctx context.Context, t *schema.Table, idx *schema.Index) error {
var (
hasExpr bool
rows, err = i.QueryContext(ctx, fmt.Sprintf(indexColumnsQuery, idx.Name))
)
if err != nil {
return fmt.Errorf("sqlite: querying %q indexes: %w", t.Name, err)
}
defer rows.Close()
for rows.Next() {
var (
desc sql.NullBool
name sql.NullString
)
if err := rows.Scan(&name, &desc); err != nil {
return fmt.Errorf("sqlite: scanning index names: %w", err)
}
part := &schema.IndexPart{
SeqNo: len(idx.Parts) + 1,
Desc: desc.Bool,
}
switch c, ok := t.Column(name.String); {
case ok:
part.C = c
// NULL name indicates that the index-part is an expression and we
// should extract it from the `CREATE INDEX` statement (not supported atm).
case !sqlx.ValidString(name):
hasExpr = true
part.X = &schema.RawExpr{X: ""}
default:
return fmt.Errorf("sqlite: column %q was not found for index %q", name.String, idx.Name)
}
idx.Parts = append(idx.Parts, part)
}
if !hasExpr {
return nil
}
var c CreateStmt
if !sqlx.Has(idx.Attrs, &c) || !reIdxParts.MatchString(c.S) {
return nil
}
parts := strings.Split(reIdxParts.FindStringSubmatch(c.S)[1], ",")
// Unable to parse index parts correctly.
if len(parts) != len(idx.Parts) {
return nil
}
for i, p := range idx.Parts {
if p.X != nil {
p.X.(*schema.RawExpr).X = strings.TrimSpace(parts[i])
}
}
return nil
}
// fks queries and appends the foreign-keys of the given table.
func (i *inspect) fks(ctx context.Context, t *schema.Table) error {
rows, err := i.QueryContext(ctx, fmt.Sprintf(fksQuery, t.Name))
if err != nil {
return fmt.Errorf("sqlite: querying %q foreign-keys: %w", t.Name, err)
}
if err := i.addFKs(t, rows); err != nil {
return fmt.Errorf("sqlite: scan %q foreign-keys: %w", t.Name, err)
}
return fillConstName(t)
}
func (i *inspect) addFKs(t *schema.Table, rows *sql.Rows) error {
ids := make(map[int]*schema.ForeignKey)
for rows.Next() {
var (
id int
column, refColumn, refTable, updateRule, deleteRule string
)
if err := rows.Scan(&id, &column, &refColumn, &refTable, &updateRule, &deleteRule); err != nil {
return err
}
fk, ok := ids[id]
if !ok {
fk = &schema.ForeignKey{
Symbol: strconv.Itoa(id),
Table: t,
RefTable: t,
OnDelete: schema.ReferenceOption(deleteRule),
OnUpdate: schema.ReferenceOption(updateRule),
}
if refTable != t.Name {
fk.RefTable = &schema.Table{Name: refTable, Schema: &schema.Schema{Name: t.Schema.Name}}
}
ids[id] = fk
t.ForeignKeys = append(t.ForeignKeys, fk)
}
c, ok := t.Column(column)
if !ok {
return fmt.Errorf("column %q was not found for fk %q", column, fk.Symbol)
}
// Rows are ordered by SEQ that specifies the
// position of the column in the FK definition.
if _, ok := fk.Column(c.Name); !ok {
fk.Columns = append(fk.Columns, c)
c.ForeignKeys = append(c.ForeignKeys, fk)
}
// Stub referenced columns or link if it is a self-reference.
var rc *schema.Column
if fk.Table != fk.RefTable {
rc = &schema.Column{Name: refColumn}
} else if c, ok := t.Column(refColumn); ok {
rc = c
} else {
return fmt.Errorf("referenced column %q was not found for fk %q", refColumn, fk.Symbol)
}
if _, ok := fk.RefColumn(rc.Name); !ok {
fk.RefColumns = append(fk.RefColumns, rc)
}
}
return nil
}
// tableNames returns a list of all tables exist in the schema.
func (i *inspect) tables(ctx context.Context, opts *schema.InspectOptions) ([]*schema.Table, error) {
var (
args []any
query = tablesQuery
)
if opts != nil && len(opts.Tables) > 0 {
query += " AND name IN (" + strings.Repeat("?, ", len(opts.Tables)-1) + "?)"
for _, s := range opts.Tables {
args = append(args, s)
}
}
rows, err := i.QueryContext(ctx, query, args...)
if err != nil {
return nil, fmt.Errorf("sqlite: querying schema tables: %w", err)
}
defer rows.Close()
var tables []*schema.Table
for rows.Next() {
var name, stmt string
if err := rows.Scan(&name, &stmt); err != nil {
return nil, fmt.Errorf("sqlite: scanning table: %w", err)
}
stmt = strings.TrimSpace(stmt)
t := &schema.Table{
Name: name,
Attrs: []schema.Attr{
&CreateStmt{S: strings.TrimSpace(stmt)},
},
}
if strings.HasSuffix(stmt, "WITHOUT ROWID") || strings.HasSuffix(stmt, "without rowid") {
t.Attrs = append(t.Attrs, &WithoutRowID{})
}
tables = append(tables, t)
}
return tables, nil
}
// schemas returns the list of the schemas in the database.
func (i *inspect) databases(ctx context.Context, opts *schema.InspectRealmOption) ([]*schema.Schema, error) {
var (
args []any
query = databasesQuery
)
if opts != nil && len(opts.Schemas) > 0 {
query = fmt.Sprintf(databasesQueryArgs, strings.Repeat("?, ", len(opts.Schemas)-1)+"?")
for _, s := range opts.Schemas {
args = append(args, s)
}
}
rows, err := i.QueryContext(ctx, query, args...)
if err != nil {
return nil, fmt.Errorf("sqlite: querying schemas: %w", err)
}
defer rows.Close()
var schemas []*schema.Schema
for rows.Next() {
var name, file sql.NullString
if err := rows.Scan(&name, &file); err != nil {
return nil, err
}
// File is missing if the database is not
// associated with a file (:memory: mode).
if file.String == "" {
file.String = ":memory:"
}
schemas = append(schemas, &schema.Schema{
Name: name.String,
Attrs: []schema.Attr{&File{Name: file.String}},
})
}
return schemas, nil
}
type (
// File describes a database file.
File struct {
schema.Attr
Name string
}
// CreateStmt describes the SQL statement used to create a resource.
CreateStmt struct {
schema.Attr
S string
}
// AutoIncrement describes the `AUTOINCREMENT` configuration.
// https://www.sqlite.org/autoinc.html
AutoIncrement struct {
schema.Attr
// Seq represents the value in sqlite_sequence table.
// i.e. https://www.sqlite.org/fileformat2.html#seqtab.
//
// Setting this value manually to > 0 indicates that
// a custom value is necessary and should be handled
// on migrate.
Seq int64
}
// WithoutRowID describes the `WITHOUT ROWID` configuration.
// See: https://sqlite.org/withoutrowid.html
WithoutRowID struct {
schema.Attr
}
// IndexPredicate describes a partial index predicate.
// See: https://www.sqlite.org/partialindex.html
IndexPredicate struct {
schema.Attr
P string
}
// IndexOrigin describes how the index was created.
// See: https://www.sqlite.org/pragma.html#pragma_index_list
IndexOrigin struct {
schema.Attr
O string
}
// A UUIDType defines a UUID type.
UUIDType struct {
schema.Type
T string
}
)
func columnParts(t string) []string {
t = strings.TrimSpace(strings.ToLower(t))
parts := strings.FieldsFunc(t, func(r rune) bool {
return r == '(' || r == ')' || r == ' ' || r == ','
})
for k := 0; k < 2; k++ {
// Join the type back if it was separated with space (e.g. 'varying character').
if len(parts) > 1 && !isNumber(parts[0]) && !isNumber(parts[1]) {
parts[1] = parts[0] + " " + parts[1]
parts = parts[1:]
}
}
return parts
}
func defaultExpr(x string) schema.Expr {
switch {
// Literals definition.
// https://www.sqlite.org/syntax/literal-value.html
case sqlx.IsLiteralBool(x), sqlx.IsLiteralNumber(x), sqlx.IsQuoted(x, '"', '\''), isBlob(x):
return &schema.Literal{V: x}
default:
// We wrap the CURRENT_TIMESTAMP literals in raw-expressions
// as they are not parsable in most decoders.
return &schema.RawExpr{X: x}
}
}
// isNumber reports whether the string is a number (category N).
func isNumber(s string) bool {
for _, r := range s {
if !unicode.IsNumber(r) {
return false
}
}
return true
}
// blob literals are hex strings preceded by 'x' (or 'X).
func isBlob(s string) bool {
if (strings.HasPrefix(s, "x'") || strings.HasPrefix(s, "X'")) && strings.HasSuffix(s, "'") {
_, err := strconv.ParseUint(s[2:len(s)-1], 16, 64)
return err == nil
}
return false
}
var reAutoinc = regexp.MustCompile("(?i)(?:[(,]\\s*)[\"`]?(\\w+)[\"`]?\\s+INTEGER\\s+[^,]*PRIMARY\\s+KEY\\s+[^,]*AUTOINCREMENT")
// autoinc checks if the table contains a "PRIMARY KEY AUTOINCREMENT" on its
// CREATE statement, according to https://www.sqlite.org/syntax/column-constraint.html.
// This is a workaround until we will embed a proper SQLite parser in atlas.
func autoinc(t *schema.Table) error {
var c CreateStmt
if !sqlx.Has(t.Attrs, &c) {
return fmt.Errorf("missing CREATE statement for table: %q", t.Name)
}
if t.PrimaryKey == nil || len(t.PrimaryKey.Parts) != 1 || t.PrimaryKey.Parts[0].C == nil {
return nil
}
matches := reAutoinc.FindStringSubmatch(c.S)
if len(matches) != 2 {
return nil
}
pkc, ok := t.Column(matches[1])
if !ok {
return fmt.Errorf("sqlite: column %q was not found for AUTOINCREMENT", matches[1])
}
if t.PrimaryKey == nil || len(t.PrimaryKey.Parts) != 1 || t.PrimaryKey.Parts[0].C != pkc {
return fmt.Errorf("sqlite: unexpected primary key: %v", t.PrimaryKey)
}
inc := &AutoIncrement{}
// Annotate table elements with "AUTOINCREMENT".
t.PrimaryKey.Attrs = append(t.PrimaryKey.Attrs, inc)
pkc.Attrs = append(pkc.Attrs, inc)
return nil
}
// setGenExpr extracts the generated expression from the CREATE statement
// and appends it to the column.
func setGenExpr(t *schema.Table, c *schema.Column, f int64) error {
var s CreateStmt
if !sqlx.Has(t.Attrs, &s) {
return fmt.Errorf("missing CREATE statement for table: %q", t.Name)
}
re, err := regexp.Compile(fmt.Sprintf("(?:[(,]\\s*)[\"`]*(%s)[\"`]*[^,]*(?i:GENERATED\\s+ALWAYS)*\\s*(?i:AS){1}\\s*\\(", c.Name))
if err != nil {
return err
}
idx := re.FindAllStringIndex(s.S, 1)
if len(idx) != 1 || len(idx[0]) != 2 {
return fmt.Errorf("sqlite: generation expression for column %q was not found in create statement", c.Name)
}
expr := scanExpr(s.S[idx[0][1]-1:])
if expr == "" {
return fmt.Errorf("sqlite: unexpected empty generation expression for column %q", c.Name)
}
typ := virtual
if f == 3 {
typ = stored
}
c.SetGeneratedExpr(&schema.GeneratedExpr{Expr: expr, Type: typ})
return nil
}
// The following regexes extract named FKs and CHECK constraints defined in table-constraints or inlined
// as column-constraints. Note, we assume the SQL statements are valid as they are returned by SQLite.
var (
reFKC = regexp.MustCompile("(?i)(?:[(,]\\s*)[\"`]*(\\w+)[\"`]*[^,]*\\s+CONSTRAINT\\s+[\"`]*(\\w+)[\"`]*\\s+REFERENCES\\s+[\"`]*(\\w+)[\"`]*\\s*\\(([,\"` \\w]+)\\)")
reFKT = regexp.MustCompile("(?i)CONSTRAINT\\s+[\"`]*(\\w+)[\"`]*\\s+FOREIGN\\s+KEY\\s*\\(([,\"` \\w]+)\\)\\s+REFERENCES\\s+[\"`]*(\\w+)[\"`]*\\s*\\(([,\"` \\w]+)\\)")
reCheck = regexp.MustCompile("(?i)(?:CONSTRAINT\\s+[\"`]?(\\w+)[\"`]?\\s+)?CHECK\\s*\\(")
)
// fillConstName fills foreign-key constrain names from CREATE TABLE statement.
func fillConstName(t *schema.Table) error {
var c CreateStmt
if !sqlx.Has(t.Attrs, &c) {
return fmt.Errorf("missing CREATE statement for table: %q", t.Name)
}
// Loop over table constraints.
for _, m := range reFKT.FindAllStringSubmatch(c.S, -1) {
if len(m) != 5 {
return fmt.Errorf("unexpected number of matches for a table constraint: %q", m)
}
// Pattern matches "constraint_name", "columns", "ref_table" and "ref_columns".
for _, fk := range t.ForeignKeys {
// Found a foreign-key match for the constraint.
if matchFK(fk, columns(m[2]), m[3], columns(m[4])) {
fk.Symbol = m[1]
break
}
}
}
// Loop over inlined column constraints.
for _, m := range reFKC.FindAllStringSubmatch(c.S, -1) {
if len(m) != 5 {
return fmt.Errorf("unexpected number of matches for a column constraint: %q", m)
}
// Pattern matches "column", "constraint_name", "ref_table" and "ref_columns".
for _, fk := range t.ForeignKeys {
// Found a foreign-key match for the constraint.
if matchFK(fk, columns(m[1]), m[3], columns(m[4])) {
fk.Symbol = m[2]
break
}
}
}
return nil
}
// columns from the matched regex above.
func columns(s string) []string {
names := strings.Split(s, ",")
for i := range names {
names[i] = strings.Trim(strings.TrimSpace(names[i]), "`\"")
}
return names
}
// matchFK reports if the foreign-key matches the given attributes.
func matchFK(fk *schema.ForeignKey, columns []string, refTable string, refColumns []string) bool {
if len(fk.Columns) != len(columns) || fk.RefTable.Name != refTable || len(fk.RefColumns) != len(refColumns) {
return false
}
for i := range columns {
if fk.Columns[i].Name != columns[i] {
return false
}
}
for i := range refColumns {
if fk.RefColumns[i].Name != refColumns[i] {
return false
}
}
return true
}
// fillChecks extracts the CHECK constrains from the CREATE TABLE statement,
// and appends them to the table attributes.
func fillChecks(t *schema.Table) error {
var c CreateStmt
if !sqlx.Has(t.Attrs, &c) {
return fmt.Errorf("missing CREATE statement for table: %q", t.Name)
}
for i := 0; i < len(c.S); {
idx := reCheck.FindStringSubmatchIndex(c.S[i:])
// No more matches.
if len(idx) != 4 {
break
}
check := &schema.Check{Expr: scanExpr(c.S[idx[1]-1:])}
// Matching group for constraint name.
if idx[2] != -1 && idx[3] != -1 {
check.Name = c.S[idx[2]:idx[3]]
}
t.Attrs = append(t.Attrs, check)
c.S = c.S[idx[1]+len(check.Expr)-1:]
}
return nil
}
// scanExpr scans the expression string (wrapped with parens)
// until its end in the given string. e.g. "(a+1), c int ...".
func scanExpr(expr string) string {
var r, l int
for i := 0; i < len(expr); i++ {
switch expr[i] {
case '(':
r++
case ')':
l++
case '\'', '"':
// Skip unescaped strings.
if j := strings.IndexByte(expr[i+1:], expr[i]); j != -1 {
i += j + 1
}
}
// Balanced parens.
if r == l {
return expr[:i+1]
}
}
return ""
}
const (
// Name of main database file.
mainFile = "main"
// Query to list attached database files.
databasesQuery = "SELECT `name`, `file` FROM pragma_database_list() WHERE `name` <> 'temp'"
databasesQueryArgs = "SELECT `name`, `file` FROM pragma_database_list() WHERE `name` IN (%s)"
// Query to list database tables.
tablesQuery = "SELECT `name`, `sql` FROM sqlite_master WHERE `type` = 'table' AND `name` NOT LIKE 'sqlite_%'"
// Query to list table information.
columnsQuery = "SELECT `name`, `type`, (not `notnull`) AS `nullable`, `dflt_value`, (`pk` <> 0) AS `pk`, `hidden` FROM pragma_table_xinfo('%s') ORDER BY `pk`, `cid`"
// Query to list table indexes.
indexesQuery = "SELECT `il`.`name`, `il`.`unique`, `il`.`origin`, `il`.`partial`, `m`.`sql` FROM pragma_index_list('%s') AS il JOIN sqlite_master AS m ON il.name = m.name"
// Query to list index columns.
indexColumnsQuery = "SELECT name, desc FROM pragma_index_xinfo('%s') WHERE key = 1 ORDER BY seqno"
// Query to list table foreign-keys.
fksQuery = "SELECT `id`, `from`, `to`, `table`, `on_update`, `on_delete` FROM pragma_foreign_key_list('%s') ORDER BY id, seq"
)
atlas-0.7.2/sql/sqlite/inspect_test.go 0000664 0000000 0000000 00000046274 14314555116 0020001 0 ustar 00root root 0000000 0000000 // Copyright 2021-present The Atlas Authors. All rights reserved.
// This source code is licensed under the Apache 2.0 license found
// in the LICENSE file in the root directory of this source tree.
package sqlite
import (
"context"
"fmt"
"testing"
"ariga.io/atlas/sql/internal/sqltest"
"ariga.io/atlas/sql/schema"
"github.com/DATA-DOG/go-sqlmock"
"github.com/stretchr/testify/require"
)
func TestDriver_InspectTable(t *testing.T) {
tests := []struct {
name string
before func(mock)
expect func(*require.Assertions, *schema.Table, error)
}{
{
name: "table columns",
before: func(m mock) {
m.tableExists("users", true, "CREATE TABLE users(id INTEGER PRIMARY KEY AUTOINCREMENT, w INT GENERATED ALWAYS AS (a*10), x TEXT AS (typeof(c)) STORED, y TEXT AS (substr(b,a,a+2)))")
m.ExpectQuery(sqltest.Escape(fmt.Sprintf(columnsQuery, "users"))).
WillReturnRows(sqltest.Rows(`
name | type | nullable | dflt_value | primary | hidden
------+--------------+----------+ ------------+----------+----------
c1 | int | 1 | a | 0 | 0
c2 | integer | 0 | 97 | 0 | 0
c3 | varchar(100) | 1 | 'A' | 0 | 0
c4 | boolean | 0 | | 0 | 0
c5 | json | 0 | | 0 | 0
c6 | datetime | 0 | | 0 | 0
c7 | blob | 0 | x'a' | 0 | 0
c8 | text | 0 | | 0 | 0
c9 | numeric(10,2) | 0 | | 0 | 0
c10 | real | 0 | | 0 | 0
w | int | 0 | | 0 | 2
x | text | 0 | | 0 | 3
y | text | 0 | | 0 | 2
id | integer | 0 | 0x1 | 1 | 0
`))
m.noIndexes("users")
m.noFKs("users")
},
expect: func(require *require.Assertions, t *schema.Table, err error) {
require.NoError(err)
columns := []*schema.Column{
{Name: "c1", Type: &schema.ColumnType{Null: true, Type: &schema.IntegerType{T: "int"}, Raw: "int"}, Default: &schema.RawExpr{X: "a"}},
{Name: "c2", Type: &schema.ColumnType{Type: &schema.IntegerType{T: "integer"}, Raw: "integer"}, Default: &schema.Literal{V: "97"}},
{Name: "c3", Type: &schema.ColumnType{Null: true, Type: &schema.StringType{T: "varchar", Size: 100}, Raw: "varchar(100)"}, Default: &schema.Literal{V: "'A'"}},
{Name: "c4", Type: &schema.ColumnType{Type: &schema.BoolType{T: "boolean"}, Raw: "boolean"}},
{Name: "c5", Type: &schema.ColumnType{Type: &schema.JSONType{T: "json"}, Raw: "json"}},
{Name: "c6", Type: &schema.ColumnType{Type: &schema.TimeType{T: "datetime"}, Raw: "datetime"}},
{Name: "c7", Type: &schema.ColumnType{Type: &schema.BinaryType{T: "blob"}, Raw: "blob"}, Default: &schema.Literal{V: "x'a'"}},
{Name: "c8", Type: &schema.ColumnType{Type: &schema.StringType{T: "text"}, Raw: "text"}},
{Name: "c9", Type: &schema.ColumnType{Type: &schema.DecimalType{T: "numeric", Precision: 10, Scale: 2}, Raw: "numeric(10,2)"}},
{Name: "c10", Type: &schema.ColumnType{Type: &schema.FloatType{T: "real"}, Raw: "real"}},
{Name: "w", Type: &schema.ColumnType{Type: &schema.IntegerType{T: "int"}, Raw: "int"}, Attrs: []schema.Attr{&schema.GeneratedExpr{Type: "VIRTUAL", Expr: "(a*10)"}}},
{Name: "x", Type: &schema.ColumnType{Type: &schema.StringType{T: "text"}, Raw: "text"}, Attrs: []schema.Attr{&schema.GeneratedExpr{Type: "STORED", Expr: "(typeof(c))"}}},
{Name: "y", Type: &schema.ColumnType{Type: &schema.StringType{T: "text"}, Raw: "text"}, Attrs: []schema.Attr{&schema.GeneratedExpr{Type: "VIRTUAL", Expr: "(substr(b,a,a+2))"}}},
{Name: "id", Type: &schema.ColumnType{Type: &schema.IntegerType{T: "integer"}, Raw: "integer"}, Attrs: []schema.Attr{&AutoIncrement{}}, Default: &schema.Literal{V: "0x1"}},
}
require.Equal(t.Columns, columns)
require.EqualValues(&schema.Index{
Name: "PRIMARY",
Unique: true,
Table: t,
Parts: []*schema.IndexPart{{SeqNo: 1, C: columns[len(columns)-1]}},
Attrs: []schema.Attr{&AutoIncrement{}},
}, t.PrimaryKey)
},
},
{
name: "table indexes",
before: func(m mock) {
m.tableExists("users", true, "CREATE TABLE users(id INTEGER PRIMARY KEY)")
m.ExpectQuery(sqltest.Escape(fmt.Sprintf(columnsQuery, "users"))).
WillReturnRows(sqltest.Rows(`
name | type | nullable | dflt_value | primary | hidden
------+--------------+----------+ ------------+----------+----------
c1 | int | 1 | | 0 | 0
c2 | integer | 0 | | 0 | 0
`))
m.ExpectQuery(sqltest.Escape(fmt.Sprintf(indexesQuery, "users"))).
WillReturnRows(sqltest.Rows(`
name | unique | origin | partial | sql
-------+--------------+--------+----------+-------------------------------------------------------
c1u | 1 | c | 0 | CREATE UNIQUE INDEX c1u on users(c1, c2)
c1_c2 | 0 | c | 1 | CREATE INDEX c1_c2 on users(c1, c2*2) WHERE c1 <> NULL
c1_x | 0 | c | 0 | CREATE INDEX c1_x ON users (f(c1))
`))
m.ExpectQuery(sqltest.Escape(fmt.Sprintf(indexColumnsQuery, "c1u"))).
WillReturnRows(sqltest.Rows(`
name | desc |
-------+--------+
c1 | 1 |
c2 | 0 |
`))
m.ExpectQuery(sqltest.Escape(fmt.Sprintf(indexColumnsQuery, "c1_c2"))).
WillReturnRows(sqltest.Rows(`
name | desc |
-------+--------+
c1 | 0 |
nil | 0 |
`))
m.ExpectQuery(sqltest.Escape(fmt.Sprintf(indexColumnsQuery, "c1_x"))).
WillReturnRows(sqltest.Rows(`
name | desc |
-------+--------+
nil | 0 |
`))
m.noFKs("users")
},
expect: func(require *require.Assertions, t *schema.Table, err error) {
require.NoError(err)
columns := []*schema.Column{
{Name: "c1", Type: &schema.ColumnType{Null: true, Type: &schema.IntegerType{T: "int"}, Raw: "int"}},
{Name: "c2", Type: &schema.ColumnType{Type: &schema.IntegerType{T: "integer"}, Raw: "integer"}},
}
indexes := []*schema.Index{
{
Name: "c1u",
Unique: true,
Table: t,
Parts: []*schema.IndexPart{
{SeqNo: 1, C: columns[0], Desc: true},
{SeqNo: 2, C: columns[1]},
},
Attrs: []schema.Attr{
&CreateStmt{S: "CREATE UNIQUE INDEX c1u on users(c1, c2)"},
&IndexOrigin{O: "c"},
},
},
{
Name: "c1_c2",
Table: t,
Parts: []*schema.IndexPart{
{SeqNo: 1, C: columns[0]},
{SeqNo: 2, X: &schema.RawExpr{X: "c2*2"}},
},
Attrs: []schema.Attr{
&CreateStmt{S: "CREATE INDEX c1_c2 on users(c1, c2*2) WHERE c1 <> NULL"},
&IndexOrigin{O: "c"},
&IndexPredicate{P: "c1 <> NULL"},
},
},
{
Name: "c1_x",
Table: t,
Parts: []*schema.IndexPart{
{SeqNo: 1, X: &schema.RawExpr{X: "f(c1)"}},
},
Attrs: []schema.Attr{
&CreateStmt{S: "CREATE INDEX c1_x ON users (f(c1))"},
&IndexOrigin{O: "c"},
},
},
}
require.Equal(t.Columns, columns)
require.Equal(t.Indexes, indexes)
},
},
{
name: "table constraints",
before: func(m mock) {
m.tableExists("users", true, `
CREATE TABLE users(
id INTEGER PRIMARY KEY,
c1 int CHECK (c1 > 10),
c2 integer NOT NULL CONSTRAINT c2_fk REFERENCES users (c1) ON DELETE SET NULL constraint "ck1" CHECK ((c1 + c2) % 2 = 0),
c3 integer NOT NULL REFERENCES users (c1) ON DELETE SET NULL,
CONSTRAINT "c1_c2_fk" FOREIGN KEY (c1, c2) REFERENCES t2 (id, c1),
CONSTRAINT "id_nonzero" CHECK (id <> 0)
)
`)
m.ExpectQuery(sqltest.Escape(fmt.Sprintf(columnsQuery, "users"))).
WillReturnRows(sqltest.Rows(`
name | type | nullable | dflt_value | primary | hidden
------+--------------+----------+ ------------+----------+----------
c1 | int | 1 | | 0 | 0
c2 | integer | 0 | | 0 | 0
c3 | integer | 0 | | 0 | 0
`))
m.noIndexes("users")
m.ExpectQuery(sqltest.Escape(fmt.Sprintf(fksQuery, "users"))).
WillReturnRows(sqltest.Rows(`
id | from | to | table | on_update | on_delete
----+-----------+-------------+-------------+-----------
0 | c1 | id | t2 | NO ACTION | CASCADE
0 | c2 | c1 | t2 | NO ACTION | CASCADE
1 | c2 | c1 | users | NO ACTION | CASCADE
`))
},
expect: func(require *require.Assertions, t *schema.Table, err error) {
require.NoError(err)
fks := []*schema.ForeignKey{
{Symbol: "c1_c2_fk", Table: t, OnUpdate: schema.NoAction, OnDelete: schema.Cascade, RefTable: &schema.Table{Name: "t2", Schema: &schema.Schema{Name: "main"}}, RefColumns: []*schema.Column{{Name: "id"}, {Name: "c1"}}},
{Symbol: "c2_fk", Table: t, OnUpdate: schema.NoAction, OnDelete: schema.Cascade, RefTable: t},
}
columns := []*schema.Column{
{Name: "c1", Type: &schema.ColumnType{Null: true, Type: &schema.IntegerType{T: "int"}, Raw: "int"}, ForeignKeys: fks[:1]},
{Name: "c2", Type: &schema.ColumnType{Type: &schema.IntegerType{T: "integer"}, Raw: "integer"}, ForeignKeys: fks},
{Name: "c3", Type: &schema.ColumnType{Type: &schema.IntegerType{T: "integer"}, Raw: "integer"}},
}
fks[0].Columns = columns[:2]
fks[1].Columns = columns[1:2]
fks[1].RefColumns = columns[:1]
checks := []schema.Attr{
&schema.Check{Expr: "(c1 > 10)"},
&schema.Check{Name: "ck1", Expr: "((c1 + c2) % 2 = 0)"},
&schema.Check{Name: "id_nonzero", Expr: "(id <> 0)"},
}
require.Equal(t.Columns, columns)
require.Equal(t.ForeignKeys, fks)
require.Equal(t.Attrs[1:], checks)
},
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
db, m, err := sqlmock.New()
require.NoError(t, err)
mk := mock{m}
mk.systemVars("3.36.0")
drv, err := Open(db)
require.NoError(t, err)
tt.before(mk)
s, err := drv.InspectSchema(context.Background(), "", &schema.InspectOptions{
Tables: []string{"users"},
})
require.NoError(t, err)
tt.expect(require.New(t), s.Tables[0], err)
})
}
}
func TestRegex_TableFK(t *testing.T) {
tests := []struct {
input string
matches []string
}{
{
input: `CREATE TABLE pets (id int NOT NULL, owner_id int, CONSTRAINT "owner_fk" FOREIGN KEY(owner_id) REFERENCES users(id))`,
matches: []string{"owner_fk", "owner_id", "users", "id"},
},
{
input: `CREATE TABLE pets (id int NOT NULL, owner_id int, CONSTRAINT "owner_fk" FOREIGN KEY (owner_id) REFERENCES users(id))`,
matches: []string{"owner_fk", "owner_id", "users", "id"},
},
{
input: `
CREATE TABLE pets (
id int NOT NULL,
owner_id int,
CONSTRAINT owner_fk
FOREIGN KEY ("owner_id") REFERENCES "users" (id)
)`,
matches: []string{"owner_fk", `"owner_id"`, "users", "id"},
},
{
input: `
CREATE TABLE pets (
id int NOT NULL,
c int,
d int,
CONSTRAINT "c_d_fk" FOREIGN KEY (c, d) REFERENCES "users" (a, b)
)`,
matches: []string{"c_d_fk", "c, d", "users", "a, b"},
},
{
input: `CREATE TABLE pets (id int NOT NULL,c int,d int,CONSTRAINT "c_d_fk" FOREIGN KEY (c, "d") REFERENCES "users" (a, "b"))`,
matches: []string{"c_d_fk", `c, "d"`, "users", `a, "b"`},
},
{
input: `CREATE TABLE pets (id int NOT NULL,c int,d int,CONSTRAINT FOREIGN KEY (c, "d") REFERENCES "users" (a, "b"))`,
},
{
input: `CREATE TABLE pets (id int NOT NULL,c int,d int,CONSTRAINT name FOREIGN KEY c REFERENCES "users" (a, "b"))`,
},
{
input: `CREATE TABLE pets (id int NOT NULL,c int,d int,CONSTRAINT name FOREIGN KEY c REFERENCES (a, "b"))`,
},
}
for _, tt := range tests {
m := reFKT.FindStringSubmatch(tt.input)
require.Equal(t, len(m) != 0, len(tt.matches) != 0)
if len(m) > 0 {
require.Equal(t, tt.matches, m[1:])
}
}
}
func TestRegex_ColumnFK(t *testing.T) {
tests := []struct {
input string
matches []string
}{
{
input: `CREATE TABLE pets (id int NOT NULL, owner_id int CONSTRAINT "owner_fk" REFERENCES users(id))`,
matches: []string{"owner_id", "owner_fk", "users", "id"},
},
{
input: `CREATE TABLE pets (id int NOT NULL, owner_id int CONSTRAINT "owner_fk" REFERENCES users(id))`,
matches: []string{"owner_id", "owner_fk", "users", "id"},
},
{
input: `
CREATE TABLE pets (
id int NOT NULL,
c int REFERENCES users(id),
d int CONSTRAINT "dfk" REFERENCES users(id)
)`,
matches: []string{"d", "dfk", "users", "id"},
},
{
input: `
CREATE TABLE t1 (
c int REFERENCES users(id),
d text CONSTRAINT "dfk" CHECK (d <> '') REFERENCES t2(d)
)`,
},
}
for _, tt := range tests {
m := reFKC.FindStringSubmatch(tt.input)
require.Equal(t, len(m) != 0, len(tt.matches) != 0)
if len(m) > 0 {
require.Equal(t, tt.matches, m[1:])
}
}
}
func TestRegex_Checks(t *testing.T) {
tests := []struct {
input string
checks []*schema.Check
}{
{
input: `CREATE TABLE pets (id int NOT NULL, owner_id int CONSTRAINT "ck1" CHECK (owner_id <> 0))`,
checks: []*schema.Check{
{Name: "ck1", Expr: "(owner_id <> 0)"},
},
},
{
input: `CREATE TABLE pets (id int NOT NULL, owner_id int CHECK (owner_id <> 0) CONSTRAINT "ck1")`,
checks: []*schema.Check{
{Expr: "(owner_id <> 0)"},
},
},
{
input: `CREATE TABLE pets (id int NOT NULL CHECK ("id" <> 0), owner_id int CONSTRAINT "ck1" CHECK ((owner_id) <> 0))`,
checks: []*schema.Check{
{Expr: `("id" <> 0)`},
{Name: "ck1", Expr: "((owner_id) <> 0)"},
},
},
{
input: `CREATE TABLE pets (id int NOT NULL CHECK ("(" <> ')'), owner_id int CONSTRAINT "ck1" CHECK ((owner_id) <> 0))`,
checks: []*schema.Check{
{Expr: `("(" <> ')')`},
{Name: "ck1", Expr: "((owner_id) <> 0)"},
},
},
{
input: "CREATE TABLE pets (\n\tid int NOT NULL CHECK (id <> 0) CHECK ((id % 2) = 0)\n,\n\towner_id int CHECK ((owner_id) <> 0)\n)",
checks: []*schema.Check{
{Expr: "(id <> 0)"},
{Expr: "((id % 2) = 0)"},
{Expr: "((owner_id) <> 0)"},
},
},
{
input: `CREATE TABLE t1(
x INTEGER CHECK( x<5 ),
y REAL CHECK( y>x ))`,
checks: []*schema.Check{
{Expr: "( x<5 )"},
{Expr: "( y>x )"},
},
},
{
input: `CREATE TABLE t(
x INTEGER CONSTRAINT one CHECK( typeof(coalesce(x,0))=="integer" ),
y NUMERIC CONSTRAINT two CHECK( typeof(coalesce(y,0.1))=='real' ),
z TEXT CONSTRAINT three CHECK( typeof(coalesce(z,''))=='text' )
)`,
checks: []*schema.Check{
{Name: "one", Expr: `( typeof(coalesce(x,0))=="integer" )`},
{Name: "two", Expr: `( typeof(coalesce(y,0.1))=='real' )`},
{Name: "three", Expr: `( typeof(coalesce(z,''))=='text' )`},
},
},
{
input: `CREATE TABLE t(
x char check ('foo''(' <> 1)
)`,
checks: []*schema.Check{
{Expr: `('foo''(' <> 1)`},
},
},
// Invalid inputs.
{
input: "CREATE TABLE t(x char check)",
},
{
input: "CREATE TABLE t(x char constraint x check)",
},
}
for _, tt := range tests {
const name = "users"
db, m, err := sqlmock.New()
require.NoError(t, err)
mk := mock{m}
mk.systemVars("3.36.0")
mk.tableExists(name, true, tt.input)
mk.noColumns(name)
mk.noIndexes(name)
mk.noFKs(name)
drv, err := Open(db)
require.NoError(t, err)
s, err := drv.InspectSchema(context.Background(), "", &schema.InspectOptions{
Tables: []string{name},
})
require.NoError(t, err)
table := s.Tables[0]
require.Equal(t, len(table.Attrs[1:]), len(tt.checks))
for i := range tt.checks {
require.Equal(t, tt.checks[i], table.Attrs[i+1])
}
}
}
func TestRegex_GeneratedExpr(t *testing.T) {
tests := []struct {
input string
column *schema.Column
}{
{
input: "CREATE TABLE t1( a NOT NULL DEFAULT 'aaa', b AS(c) NOT NULL, c NOT NULL DEFAULT 'ccc');",
column: schema.NewColumn("b").
SetGeneratedExpr(&schema.GeneratedExpr{Expr: "(c)", Type: "VIRTUAL"}),
},
{
input: "CREATE TABLE t4(a NOT NULL DEFAULT 123, b AS(a*10+4) STORED UNIQUE);",
column: schema.NewColumn("b").
SetGeneratedExpr(&schema.GeneratedExpr{Expr: "(a*10+4)", Type: "VIRTUAL"}),
},
{
input: "CREATE TABLE t1(aa , bb AS (17) UNIQUE);",
column: schema.NewColumn("bb").
SetGeneratedExpr(&schema.GeneratedExpr{Expr: "(17)", Type: "VIRTUAL"}),
},
{
input: "CREATE TABLE t1( a integer primary key, b int generated always as (a+5), c text GENERATED ALWAYS as (printf('%08x',a)));",
column: schema.NewColumn("c").
SetGeneratedExpr(&schema.GeneratedExpr{Expr: "(printf('%08x',a))", Type: "VIRTUAL"}),
},
{
input: "CREATE TABLE t1( a integer primary key, b int generated always as (a+5), c text GENERATED ALWAYS as (printf('%08x',a)), d Generated\nAlways\nAS\n('xy\\()zzy'));",
column: schema.NewColumn("d").
SetGeneratedExpr(&schema.GeneratedExpr{Expr: "('xy\\()zzy')", Type: "VIRTUAL"}),
},
{
input: "CREATE TABLE t0( c0 AS (('a', 9) < ('b', c1)), c1 AS (1), c2 CHECK (1 = c1) );",
column: schema.NewColumn("c0").
SetGeneratedExpr(&schema.GeneratedExpr{Expr: "(('a', 9) < ('b', c1))", Type: "VIRTUAL"}),
},
}
for _, tt := range tests {
const name = "users"
db, m, err := sqlmock.New()
require.NoError(t, err)
mk := mock{m}
mk.systemVars("3.36.0")
mk.tableExists(name, true, tt.input)
m.ExpectQuery(sqltest.Escape(fmt.Sprintf(columnsQuery, name))).
WillReturnRows(sqltest.Rows(fmt.Sprintf(`
name | type | nullable | dflt_value | primary | hidden
------+--------------+----------+ ------------+----------+----------
%s | int | 1 | a | 0 | 2
`, tt.column.Name)))
mk.noIndexes(name)
mk.noFKs(name)
drv, err := Open(db)
require.NoError(t, err)
s, err := drv.InspectSchema(context.Background(), "", &schema.InspectOptions{
Tables: []string{name},
})
require.NoError(t, err)
require.Equal(t, tt.column.Attrs, s.Tables[0].Columns[0].Attrs)
}
}
type mock struct {
sqlmock.Sqlmock
}
func (m mock) systemVars(version string) {
m.ExpectQuery(sqltest.Escape("SELECT sqlite_version()")).
WillReturnRows(sqltest.Rows(`
version
----------------
` + version + `
`))
m.ExpectQuery(sqltest.Escape("SELECT name FROM pragma_collation_list()")).
WillReturnRows(sqltest.Rows(`
pragma_collation_list
------------------------
decimal
uint
RTRIM
NOCASE
BINARY
`))
}
func (m mock) tableExists(table string, exists bool, stmt ...string) {
m.ExpectQuery(sqltest.Escape(fmt.Sprintf(databasesQueryArgs, "?"))).
WithArgs("main").
WillReturnRows(sqltest.Rows(`
name | file
------+-----------
main |
`))
rows := sqlmock.NewRows([]string{"name", "sql"})
if exists {
rows.AddRow(table, stmt[0])
}
m.ExpectQuery(sqltest.Escape(tablesQuery + " AND name IN (?)")).
WithArgs(table).
WillReturnRows(rows)
}
func (m mock) noColumns(table string) {
m.ExpectQuery(sqltest.Escape(fmt.Sprintf(columnsQuery, table))).
WillReturnRows(sqlmock.NewRows([]string{"name", "type", "nullable", "dflt_value", "primary"}))
}
func (m mock) noIndexes(table string) {
m.ExpectQuery(sqltest.Escape(fmt.Sprintf(indexesQuery, table))).
WillReturnRows(sqlmock.NewRows([]string{"name", "unique", "origin", "partial", "sql"}))
}
func (m mock) noFKs(table string) {
m.ExpectQuery(sqltest.Escape(fmt.Sprintf(fksQuery, table))).
WillReturnRows(sqlmock.NewRows([]string{"id", "from", "to", "table", "on_update", "on_delete"}))
}
atlas-0.7.2/sql/sqlite/migrate.go 0000664 0000000 0000000 00000042321 14314555116 0016712 0 ustar 00root root 0000000 0000000 // Copyright 2021-present The Atlas Authors. All rights reserved.
// This source code is licensed under the Apache 2.0 license found
// in the LICENSE file in the root directory of this source tree.
package sqlite
import (
"context"
"fmt"
"strings"
"ariga.io/atlas/sql/internal/sqlx"
"ariga.io/atlas/sql/migrate"
"ariga.io/atlas/sql/schema"
)
// A planApply provides migration capabilities for schema elements.
type planApply struct{ conn }
// PlanChanges returns a migration plan for the given schema changes.
func (p *planApply) PlanChanges(ctx context.Context, name string, changes []schema.Change, opts ...migrate.PlanOption) (*migrate.Plan, error) {
s := &state{
conn: p.conn,
Plan: migrate.Plan{
Name: name,
Reversible: true,
Transactional: true,
},
PlanOptions: migrate.PlanOptions{
// Currently, the driver does not support attached
// schemas and assumed the connected schema is "main".
SchemaQualifier: new(string),
},
}
for _, o := range opts {
o(&s.PlanOptions)
}
if err := s.plan(ctx, changes); err != nil {
return nil, err
}
for _, c := range s.Changes {
if c.Reverse == "" {
s.Reversible = false
}
}
return &s.Plan, nil
}
// ApplyChanges applies the changes on the database. An error is returned
// if the driver is unable to produce a plan to it, or one of the statements
// is failed or unsupported.
func (p *planApply) ApplyChanges(ctx context.Context, changes []schema.Change, opts ...migrate.PlanOption) error {
return sqlx.ApplyChanges(ctx, changes, p, opts...)
}
// state represents the state of a planning. It's not part of
// planApply so that multiple planning/applying can be called
// in parallel.
type state struct {
conn
migrate.Plan
migrate.PlanOptions
skipFKs bool
}
// Exec executes the changes on the database. An error is returned
// if one of the operations fail, or a change is not supported.
func (s *state) plan(ctx context.Context, changes []schema.Change) (err error) {
for _, c := range changes {
switch c := c.(type) {
case *schema.AddTable:
err = s.addTable(ctx, c)
case *schema.DropTable:
err = s.dropTable(c)
case *schema.ModifyTable:
err = s.modifyTable(ctx, c)
case *schema.RenameTable:
s.renameTable(c)
default:
err = fmt.Errorf("unsupported change %T", c)
}
if err != nil {
return err
}
}
// Disable foreign-keys enforcement if it is required
// by one of the changes in the plan.
if s.skipFKs {
// Callers should note that these 2 pragmas are no-op in transactions,
// See: https://sqlite.org/pragma.html#pragma_foreign_keys.
s.Changes = append([]*migrate.Change{{Cmd: "PRAGMA foreign_keys = off", Comment: "disable the enforcement of foreign-keys constraints"}}, s.Changes...)
s.append(&migrate.Change{Cmd: "PRAGMA foreign_keys = on", Comment: "enable back the enforcement of foreign-keys constraints"})
}
return nil
}
// addTable builds and executes the query for creating a table in a schema.
func (s *state) addTable(ctx context.Context, add *schema.AddTable) error {
var (
errs []string
b = s.Build("CREATE TABLE").Table(add.T)
)
if sqlx.Has(add.Extra, &schema.IfNotExists{}) {
b.P("IF NOT EXISTS")
}
b.Wrap(func(b *sqlx.Builder) {
b.MapComma(add.T.Columns, func(i int, b *sqlx.Builder) {
if err := s.column(b, add.T.Columns[i]); err != nil {
errs = append(errs, err.Error())
}
})
// Primary keys with auto-increment are inlined on the column definition.
if pk := add.T.PrimaryKey; pk != nil && !autoincPK(pk) {
b.Comma().P("PRIMARY KEY")
s.indexParts(b, pk.Parts)
}
if len(add.T.ForeignKeys) > 0 {
b.Comma()
s.fks(b, add.T.ForeignKeys...)
}
for _, attr := range add.T.Attrs {
if c, ok := attr.(*schema.Check); ok {
b.Comma()
check(b, c)
}
}
})
if len(errs) > 0 {
return fmt.Errorf("create table %q: %s", add.T.Name, strings.Join(errs, ", "))
}
if p := (WithoutRowID{}); sqlx.Has(add.T.Attrs, &p) {
b.P("WITHOUT ROWID")
}
s.append(&migrate.Change{
Cmd: b.String(),
Source: add,
Reverse: s.Build("DROP TABLE").Table(add.T).String(),
Comment: fmt.Sprintf("create %q table", add.T.Name),
})
if err := s.tableSeq(ctx, add); err != nil {
return err
}
return s.addIndexes(add.T, add.T.Indexes...)
}
// dropTable builds and executes the query for dropping a table from a schema.
func (s *state) dropTable(drop *schema.DropTable) error {
s.skipFKs = true
b := s.Build("DROP TABLE").Ident(drop.T.Name)
if sqlx.Has(drop.Extra, &schema.IfExists{}) {
b.P("IF EXISTS")
}
s.append(&migrate.Change{
Cmd: b.String(),
Source: drop,
Comment: fmt.Sprintf("drop %q table", drop.T.Name),
})
return nil
}
// modifyTable builds and executes the queries for bringing the table into its modified state.
// If the modification contains changes that are not index creation/deletion or a simple column
// addition, the changes are applied using a temporary table following the procedure mentioned
// in: https://www.sqlite.org/lang_altertable.html#making_other_kinds_of_table_schema_changes.
func (s *state) modifyTable(ctx context.Context, modify *schema.ModifyTable) error {
if alterable(modify) {
return s.alterTable(modify)
}
s.skipFKs = true
newT := *modify.T
indexes := newT.Indexes
newT.Indexes = nil
newT.Name = "new_" + newT.Name
// Create a new table with a temporary name, and copy the existing rows to it.
if err := s.addTable(ctx, &schema.AddTable{T: &newT}); err != nil {
return err
}
copied, err := s.copyRows(modify.T, &newT, modify.Changes)
if err != nil {
return err
}
// Drop the current table, and rename the new one to its real name.
s.append(&migrate.Change{
Cmd: s.Build("DROP TABLE").Ident(modify.T.Name).String(),
Source: modify,
Comment: fmt.Sprintf("drop %q table %s", modify.T.Name, func() string {
if copied {
return "after copying rows"
}
return "without copying rows (no columns)"
}()),
})
s.append(&migrate.Change{
Cmd: s.Build("ALTER TABLE").Ident(newT.Name).P("RENAME TO").Ident(modify.T.Name).String(),
Source: modify,
Comment: fmt.Sprintf("rename temporary table %q to %q", newT.Name, modify.T.Name),
})
return s.addIndexes(modify.T, indexes...)
}
func (s *state) renameTable(c *schema.RenameTable) {
s.append(&migrate.Change{
Source: c,
Comment: fmt.Sprintf("rename a table from %q to %q", c.From.Name, c.To.Name),
Cmd: s.Build("ALTER TABLE").Table(c.From).P("RENAME TO").Table(c.To).String(),
Reverse: s.Build("ALTER TABLE").Table(c.To).P("RENAME TO").Table(c.From).String(),
})
}
func (s *state) column(b *sqlx.Builder, c *schema.Column) error {
t, err := FormatType(c.Type.Type)
if err != nil {
return err
}
b.Ident(c.Name).P(t)
if !c.Type.Null {
b.P("NOT")
}
b.P("NULL")
if c.Default != nil {
x, err := defaultValue(c)
if err != nil {
return err
}
b.P("DEFAULT", x)
}
switch hasA, hasX := sqlx.Has(c.Attrs, &AutoIncrement{}), sqlx.Has(c.Attrs, &schema.GeneratedExpr{}); {
case hasA && hasX:
return fmt.Errorf("both autoincrement and generation expression specified for column %q", c.Name)
case hasA:
b.P("PRIMARY KEY AUTOINCREMENT")
case hasX:
x := &schema.GeneratedExpr{}
sqlx.Has(c.Attrs, x)
b.P("AS", sqlx.MayWrap(x.Expr), x.Type)
}
return nil
}
func (s *state) dropIndexes(t *schema.Table, indexes ...*schema.Index) error {
rs := &state{conn: s.conn}
if err := rs.addIndexes(t, indexes...); err != nil {
return err
}
for i := range rs.Changes {
s.append(&migrate.Change{
Cmd: rs.Changes[i].Reverse,
Reverse: rs.Changes[i].Cmd,
Comment: fmt.Sprintf("drop index %q from table: %q", indexes[i].Name, t.Name),
})
}
return nil
}
func (s *state) addIndexes(t *schema.Table, indexes ...*schema.Index) error {
for _, idx := range indexes {
// PRIMARY KEY or UNIQUE columns automatically create indexes with the generated name.
// See: sqlite/build.c#sqlite3CreateIndex. Therefore, we ignore such PKs, but create
// the inlined UNIQUE constraints manually with custom name, because SQLite does not
// allow creating indexes with such names manually. Note, this case is possible if
// "apply" schema that was inspected from the database as-is.
if strings.HasPrefix(idx.Name, "sqlite_autoindex") {
if i := (IndexOrigin{}); sqlx.Has(idx.Attrs, &i) && i.O == "p" {
continue
}
// Use the following format:
_.
names := make([]string, len(idx.Parts)+1)
names[0] = t.Name
for i, p := range idx.Parts {
if p.C == nil {
return fmt.Errorf("unexpected index part %s (%d)", idx.Name, i)
}
names[i+1] = p.C.Name
}
idx.Name = strings.Join(names, "_")
}
b := s.Build("CREATE")
if idx.Unique {
b.P("UNIQUE")
}
b.P("INDEX")
if idx.Name != "" {
b.Ident(idx.Name)
}
b.P("ON").Ident(t.Name)
s.indexParts(b, idx.Parts)
if p := (IndexPredicate{}); sqlx.Has(idx.Attrs, &p) {
b.P("WHERE").P(p.P)
}
s.append(&migrate.Change{
Cmd: b.String(),
Source: &schema.AddIndex{I: idx},
Reverse: s.Build("DROP INDEX").Ident(idx.Name).String(),
Comment: fmt.Sprintf("create index %q to table: %q", idx.Name, t.Name),
})
}
return nil
}
func (s *state) indexParts(b *sqlx.Builder, parts []*schema.IndexPart) {
b.Wrap(func(b *sqlx.Builder) {
b.MapComma(parts, func(i int, b *sqlx.Builder) {
switch part := parts[i]; {
case part.C != nil:
b.Ident(part.C.Name)
case part.X != nil:
b.WriteString(sqlx.MayWrap(part.X.(*schema.RawExpr).X))
}
if parts[i].Desc {
b.P("DESC")
}
})
})
}
func (s *state) fks(b *sqlx.Builder, fks ...*schema.ForeignKey) {
b.MapComma(fks, func(i int, b *sqlx.Builder) {
fk := fks[i]
if fk.Symbol != "" {
b.P("CONSTRAINT").Ident(fk.Symbol)
}
b.P("FOREIGN KEY")
b.Wrap(func(b *sqlx.Builder) {
b.MapComma(fk.Columns, func(i int, b *sqlx.Builder) {
b.Ident(fk.Columns[i].Name)
})
})
b.P("REFERENCES").Ident(fk.RefTable.Name)
b.Wrap(func(b *sqlx.Builder) {
b.MapComma(fk.RefColumns, func(i int, b *sqlx.Builder) {
b.Ident(fk.RefColumns[i].Name)
})
})
if fk.OnUpdate != "" {
b.P("ON UPDATE", string(fk.OnUpdate))
}
if fk.OnDelete != "" {
b.P("ON DELETE", string(fk.OnDelete))
}
})
}
func (s *state) copyRows(from *schema.Table, to *schema.Table, changes []schema.Change) (bool, error) {
var fromC, toC []string
for _, column := range to.Columns {
// Skip generated columns in INSERT as they are computed.
if sqlx.Has(column.Attrs, &schema.GeneratedExpr{}) {
continue
}
// Find a change that associated with this column, if exists.
var change schema.Change
for i := range changes {
switch c := changes[i].(type) {
case *schema.AddColumn:
if c.C.Name != column.Name {
break
}
if change != nil {
return false, fmt.Errorf("duplicate changes for column: %q: %T, %T", column.Name, change, c)
}
change = changes[i]
case *schema.ModifyColumn:
if c.To.Name != column.Name {
break
}
if change != nil {
return false, fmt.Errorf("duplicate changes for column: %q: %T, %T", column.Name, change, c)
}
change = changes[i]
case *schema.DropColumn:
if c.C.Name == column.Name {
return false, fmt.Errorf("unexpected drop column: %q", column.Name)
}
}
}
switch change := change.(type) {
// We expect that new columns are added with DEFAULT/GENERATED
// values or defined as nullable if the table is not empty.
case *schema.AddColumn:
// Column modification requires special handling if it was
// converted from nullable to non-nullable with default value.
case *schema.ModifyColumn:
toC = append(toC, column.Name)
if !column.Type.Null && column.Default != nil && change.Change.Is(schema.ChangeNull|schema.ChangeDefault) {
x, err := defaultValue(column)
if err != nil {
return false, err
}
fromC = append(fromC, fmt.Sprintf("IFNULL(`%[1]s`, %s) AS `%[1]s`", column.Name, x))
} else {
fromC = append(fromC, column.Name)
}
// Columns without changes should be transferred as-is.
case nil:
toC = append(toC, column.Name)
fromC = append(fromC, column.Name)
}
}
insert := len(toC) > 0
if insert {
s.append(&migrate.Change{
Cmd: fmt.Sprintf(
"INSERT INTO `%s` (%s) SELECT %s FROM `%s`",
to.Name, identComma(toC), identComma(fromC), from.Name,
),
Comment: fmt.Sprintf("copy rows from old table %q to new temporary table %q", from.Name, to.Name),
})
}
return insert, nil
}
// alterTable alters the table with the given changes. Assuming the changes are "alterable".
func (s *state) alterTable(modify *schema.ModifyTable) error {
for _, change := range modify.Changes {
switch change := change.(type) {
case *schema.AddIndex:
if err := s.addIndexes(modify.T, change.I); err != nil {
return err
}
case *schema.DropIndex:
if err := s.dropIndexes(modify.T, change.I); err != nil {
return err
}
case *schema.RenameIndex:
if err := s.addIndexes(modify.T, change.To); err != nil {
return err
}
if err := s.dropIndexes(modify.T, change.From); err != nil {
return err
}
case *schema.AddColumn:
b := s.Build("ALTER TABLE").Ident(modify.T.Name)
r := b.Clone()
if err := s.column(b.P("ADD COLUMN"), change.C); err != nil {
return err
}
s.append(&migrate.Change{
Source: change,
Cmd: b.String(),
Reverse: r.P("DROP COLUMN").Ident(change.C.Name).String(),
Comment: fmt.Sprintf("add column %q to table: %q", change.C.Name, modify.T.Name),
})
case *schema.RenameColumn:
b := s.Build("ALTER TABLE").Ident(modify.T.Name).P("RENAME COLUMN")
r := b.Clone()
s.append(&migrate.Change{
Source: change,
Cmd: b.Ident(change.From.Name).P("TO").Ident(change.To.Name).String(),
Reverse: r.Ident(change.To.Name).P("TO").Ident(change.From.Name).String(),
Comment: fmt.Sprintf("rename a column from %q to %q", change.From.Name, change.To.Name),
})
default:
return fmt.Errorf("unexpected change in alter table: %T", change)
}
}
return nil
}
// tableSeq sets the sequence value of the table if it was provided by
// the user on table creation.
func (s *state) tableSeq(ctx context.Context, add *schema.AddTable) error {
var inc AutoIncrement
switch pk := add.T.PrimaryKey; {
// Sequence was set on the table.
case sqlx.Has(add.T.Attrs, &inc) && inc.Seq > 0:
// Sequence was set on table primary-key (a single column PK).
case pk != nil && len(pk.Parts) == 1 && pk.Parts[0].C != nil && sqlx.Has(pk.Parts[0].C.Attrs, &inc) && inc.Seq > 0:
default:
return nil
}
// SQLite tracks the AUTOINCREMENT in the "sqlite_sequence" table that is created and initialized automatically
// whenever the first "PRIMARY KEY AUTOINCREMENT" is created. However, rows in this table are populated after the
// first insertion to the associated table (name, seq). Therefore, we check if the sequence table and the row exist,
// and in case they are not, we insert a new non-zero sequence to it.
rows, err := s.QueryContext(ctx, "SELECT seq FROM sqlite_sequence WHERE name = ?", add.T.Name)
if err != nil || !rows.Next() {
s.append(&migrate.Change{
Cmd: fmt.Sprintf("INSERT INTO sqlite_sequence (name, seq) VALUES (%q, %d)", add.T.Name, inc.Seq),
Source: add,
Reverse: fmt.Sprintf("UPDATE sqlite_sequence SET seq = 0 WHERE name = %q", add.T.Name),
Comment: fmt.Sprintf("set sequence for %q table", add.T.Name),
})
}
if rows != nil {
return rows.Close()
}
return nil
}
func (s *state) append(c *migrate.Change) {
s.Changes = append(s.Changes, c)
}
func alterable(modify *schema.ModifyTable) bool {
for _, change := range modify.Changes {
switch change := change.(type) {
case *schema.RenameColumn, *schema.RenameIndex, *schema.DropIndex, *schema.AddIndex:
case *schema.AddColumn:
if len(change.C.Indexes) > 0 || len(change.C.ForeignKeys) > 0 || change.C.Default != nil {
return false
}
// Only VIRTUAL generated columns can be added using ALTER TABLE.
if x := (schema.GeneratedExpr{}); sqlx.Has(change.C.Attrs, &x) && storedOrVirtual(x.Type) == stored {
return false
}
default:
return false
}
}
return true
}
// checks writes the CHECK constraint to the builder.
func check(b *sqlx.Builder, c *schema.Check) {
expr := c.Expr
// Expressions should be wrapped with parens.
if t := strings.TrimSpace(expr); !strings.HasPrefix(t, "(") || !strings.HasSuffix(t, ")") {
expr = "(" + t + ")"
}
if c.Name != "" {
b.P("CONSTRAINT").Ident(c.Name)
}
b.P("CHECK", expr)
}
func autoincPK(pk *schema.Index) bool {
return sqlx.Has(pk.Attrs, &AutoIncrement{}) ||
len(pk.Parts) == 1 && pk.Parts[0].C != nil && sqlx.Has(pk.Parts[0].C.Attrs, &AutoIncrement{})
}
// Build instantiates a new builder and writes the given phrase to it.
func (s *state) Build(phrases ...string) *sqlx.Builder {
b := &sqlx.Builder{QuoteChar: '`', Schema: s.SchemaQualifier}
return b.P(phrases...)
}
func defaultValue(c *schema.Column) (string, error) {
switch x := c.Default.(type) {
case *schema.Literal:
switch c.Type.Type.(type) {
case *schema.BoolType, *schema.DecimalType, *schema.IntegerType, *schema.FloatType:
return x.V, nil
default:
return sqlx.SingleQuote(x.V)
}
case *schema.RawExpr:
return x.X, nil
default:
return "", fmt.Errorf("unexpected default value type: %T", x)
}
}
func identComma(c []string) string {
b := &sqlx.Builder{QuoteChar: '`'}
b.MapComma(c, func(i int, b *sqlx.Builder) {
if strings.ContainsRune(c[i], '`') {
b.WriteString(c[i])
} else {
b.Ident(c[i])
}
})
return b.String()
}
atlas-0.7.2/sql/sqlite/migrate_test.go 0000664 0000000 0000000 00000026640 14314555116 0017757 0 ustar 00root root 0000000 0000000 // Copyright 2021-present The Atlas Authors. All rights reserved.
// This source code is licensed under the Apache 2.0 license found
// in the LICENSE file in the root directory of this source tree.
package sqlite
import (
"context"
"database/sql"
"strconv"
"testing"
"ariga.io/atlas/sql/internal/sqltest"
"ariga.io/atlas/sql/migrate"
"ariga.io/atlas/sql/schema"
"github.com/DATA-DOG/go-sqlmock"
"github.com/stretchr/testify/require"
)
func TestPlanChanges(t *testing.T) {
tests := []struct {
changes []schema.Change
options []migrate.PlanOption
mock func(mock)
plan *migrate.Plan
}{
{
changes: []schema.Change{
&schema.AddTable{
T: &schema.Table{
Name: "posts",
Columns: []*schema.Column{
{Name: "id", Type: &schema.ColumnType{Type: &schema.IntegerType{T: "integer"}}},
{Name: "text", Type: &schema.ColumnType{Type: &schema.StringType{T: "text"}, Null: true}},
},
Attrs: []schema.Attr{
&schema.Check{Expr: "(text <> '')"},
&schema.Check{Name: "positive_id", Expr: "(id <> 0)"},
},
},
},
},
plan: &migrate.Plan{
Reversible: true,
Transactional: true,
Changes: []*migrate.Change{{Cmd: "CREATE TABLE `posts` (`id` integer NOT NULL, `text` text NULL, CHECK (text <> ''), CONSTRAINT `positive_id` CHECK (id <> 0))", Reverse: "DROP TABLE `posts`"}},
},
},
{
changes: []schema.Change{
&schema.AddTable{
T: &schema.Table{
Name: "posts",
Columns: []*schema.Column{
{Name: "id", Type: &schema.ColumnType{Type: &schema.IntegerType{T: "integer"}}, Attrs: []schema.Attr{&AutoIncrement{Seq: 1024}}},
{Name: "text", Type: &schema.ColumnType{Type: &schema.StringType{T: "text"}, Null: true}},
},
Attrs: []schema.Attr{
&schema.Check{Expr: "(text <> '')"},
&schema.Check{Name: "positive_id", Expr: "(id <> 0)"},
},
},
},
},
mock: func(m mock) {
m.ExpectQuery(sqltest.Escape("SELECT seq FROM sqlite_sequence WHERE name = ?")).
WithArgs("posts").
WillReturnError(sql.ErrNoRows)
},
plan: &migrate.Plan{
Reversible: true,
Transactional: true,
Changes: []*migrate.Change{
{Cmd: "CREATE TABLE `posts` (`id` integer NOT NULL PRIMARY KEY AUTOINCREMENT, `text` text NULL, CHECK (text <> ''), CONSTRAINT `positive_id` CHECK (id <> 0))", Reverse: "DROP TABLE `posts`"},
{Cmd: `INSERT INTO sqlite_sequence (name, seq) VALUES ("posts", 1024)`, Reverse: `UPDATE sqlite_sequence SET seq = 0 WHERE name = "posts"`},
},
},
},
{
changes: []schema.Change{
&schema.DropTable{T: &schema.Table{Name: "posts"}},
},
plan: &migrate.Plan{
Transactional: true,
Changes: []*migrate.Change{
{Cmd: "PRAGMA foreign_keys = off"},
{Cmd: "DROP TABLE `posts`"},
{Cmd: "PRAGMA foreign_keys = on"},
},
},
},
{
changes: []schema.Change{
func() schema.Change {
users := &schema.Table{
Name: "users",
Columns: []*schema.Column{
{Name: "id", Type: &schema.ColumnType{Type: &schema.IntegerType{T: "bigint"}}},
},
}
return &schema.ModifyTable{
T: users,
Changes: []schema.Change{
&schema.AddColumn{
C: &schema.Column{Name: "name", Type: &schema.ColumnType{Type: &schema.StringType{T: "varchar(255)"}}},
},
&schema.AddIndex{
I: &schema.Index{
Name: "id_key",
Parts: []*schema.IndexPart{
{C: users.Columns[0]},
},
Attrs: []schema.Attr{
&schema.Comment{Text: "comment"},
},
},
},
},
}
}(),
},
plan: &migrate.Plan{
Reversible: true,
Transactional: true,
Changes: []*migrate.Change{
{Cmd: "ALTER TABLE `users` ADD COLUMN `name` varchar(255) NOT NULL", Reverse: "ALTER TABLE `users` DROP COLUMN `name`"},
{Cmd: "CREATE INDEX `id_key` ON `users` (`id`)", Reverse: "DROP INDEX `id_key`"},
},
},
},
// Add VIRTUAL column.
{
changes: []schema.Change{
func() schema.Change {
users := schema.NewTable("users").
AddColumns(schema.NewIntColumn("id", "bigint"))
return &schema.ModifyTable{
T: users,
Changes: []schema.Change{
&schema.AddColumn{
C: schema.NewIntColumn("nid", "bigint").
SetGeneratedExpr(&schema.GeneratedExpr{Expr: "1"}),
},
},
}
}(),
},
plan: &migrate.Plan{
Reversible: true,
Transactional: true,
Changes: []*migrate.Change{
{Cmd: "ALTER TABLE `users` ADD COLUMN `nid` bigint NOT NULL AS (1)", Reverse: "ALTER TABLE `users` DROP COLUMN `nid`"},
},
},
},
// Add STORED column.
{
changes: []schema.Change{
func() schema.Change {
users := schema.NewTable("users").
AddColumns(
schema.NewIntColumn("id", "bigint"),
schema.NewIntColumn("nid", "bigint").
SetGeneratedExpr(&schema.GeneratedExpr{Expr: "1", Type: "STORED"}),
)
return &schema.ModifyTable{
T: users,
Changes: []schema.Change{
&schema.AddColumn{
C: users.Columns[1],
},
},
}
}(),
},
plan: &migrate.Plan{
Transactional: true,
Changes: []*migrate.Change{
{Cmd: "PRAGMA foreign_keys = off"},
{Cmd: "CREATE TABLE `new_users` (`id` bigint NOT NULL, `nid` bigint NOT NULL AS (1) STORED)", Reverse: "DROP TABLE `new_users`"},
{Cmd: "INSERT INTO `new_users` (`id`) SELECT `id` FROM `users`"},
{Cmd: "DROP TABLE `users`"},
{Cmd: "ALTER TABLE `new_users` RENAME TO `users`"},
{Cmd: "PRAGMA foreign_keys = on"},
},
},
},
{
changes: []schema.Change{
func() schema.Change {
users := &schema.Table{
Name: "users",
Columns: []*schema.Column{
schema.NewIntColumn("id", "bigint"),
schema.NewIntColumn("rank", "int").SetDefault(&schema.Literal{V: "1"}),
schema.NewStringColumn("nick", "text").SetDefault(&schema.Literal{V: "a8m"}),
},
Attrs: []schema.Attr{
&schema.Check{Expr: "(id <> 0)"},
},
}
return &schema.ModifyTable{
T: users,
Changes: []schema.Change{
&schema.ModifyColumn{
From: schema.NewNullIntColumn("id", "bigint"),
To: users.Columns[1],
Change: schema.ChangeNull | schema.ChangeDefault,
},
&schema.ModifyColumn{
From: schema.NewNullStringColumn("nick", "text"),
To: users.Columns[2],
Change: schema.ChangeNull | schema.ChangeDefault,
},
&schema.DropColumn{
C: &schema.Column{Name: "name", Type: &schema.ColumnType{Type: &schema.StringType{T: "varchar(255)"}}},
},
&schema.AddCheck{
C: &schema.Check{Expr: "(id <> 0)"},
},
},
}
}(),
},
plan: &migrate.Plan{
Transactional: true,
Changes: []*migrate.Change{
{Cmd: "PRAGMA foreign_keys = off"},
{Cmd: "CREATE TABLE `new_users` (`id` bigint NOT NULL, `rank` int NOT NULL DEFAULT 1, `nick` text NOT NULL DEFAULT 'a8m', CHECK (id <> 0))", Reverse: "DROP TABLE `new_users`"},
{Cmd: "INSERT INTO `new_users` (`id`, `rank`, `nick`) SELECT `id`, IFNULL(`rank`, 1) AS `rank`, IFNULL(`nick`, 'a8m') AS `nick` FROM `users`"},
{Cmd: "DROP TABLE `users`"},
{Cmd: "ALTER TABLE `new_users` RENAME TO `users`"},
{Cmd: "PRAGMA foreign_keys = on"},
},
},
},
// Nothing to INSERT.
{
changes: []schema.Change{
func() schema.Change {
users := &schema.Table{
Name: "users",
Columns: []*schema.Column{
{Name: "c2", Type: &schema.ColumnType{Type: &schema.IntegerType{T: "bigint"}}},
},
}
return &schema.ModifyTable{
T: users,
Changes: []schema.Change{
&schema.DropColumn{
C: &schema.Column{Name: "c1", Type: &schema.ColumnType{Type: &schema.StringType{T: "varchar(255)"}}},
},
&schema.AddColumn{
C: &schema.Column{Name: "c2", Type: &schema.ColumnType{Type: &schema.IntegerType{T: "bigint"}}},
},
},
}
}(),
},
plan: &migrate.Plan{
Transactional: true,
Changes: []*migrate.Change{
{Cmd: "PRAGMA foreign_keys = off"},
{Cmd: "CREATE TABLE `new_users` (`c2` bigint NOT NULL)", Reverse: "DROP TABLE `new_users`"},
/* Nothing to INSERT from `users` as `c1` was dropped. */
{Cmd: "DROP TABLE `users`"},
{Cmd: "ALTER TABLE `new_users` RENAME TO `users`"},
{Cmd: "PRAGMA foreign_keys = on"},
},
},
},
{
changes: []schema.Change{
&schema.RenameTable{
From: schema.NewTable("t1"),
To: schema.NewTable("t2"),
},
},
plan: &migrate.Plan{
Reversible: true,
Transactional: true,
Changes: []*migrate.Change{
{
Cmd: "ALTER TABLE `t1` RENAME TO `t2`",
Reverse: "ALTER TABLE `t2` RENAME TO `t1`",
},
},
},
},
{
changes: []schema.Change{
&schema.ModifyTable{
T: schema.NewTable("t1"),
Changes: []schema.Change{
&schema.RenameColumn{
From: schema.NewColumn("a"),
To: schema.NewColumn("b"),
},
},
},
},
plan: &migrate.Plan{
Reversible: true,
Transactional: true,
Changes: []*migrate.Change{
{
Cmd: "ALTER TABLE `t1` RENAME COLUMN `a` TO `b`",
Reverse: "ALTER TABLE `t1` RENAME COLUMN `b` TO `a`",
},
},
},
},
{
changes: []schema.Change{
&schema.ModifyTable{
T: schema.NewTable("t1"),
Changes: []schema.Change{
&schema.RenameIndex{
From: schema.NewIndex("a").AddColumns(schema.NewColumn("a")),
To: schema.NewIndex("b").AddColumns(schema.NewColumn("a")),
},
},
},
},
plan: &migrate.Plan{
Reversible: true,
Transactional: true,
Changes: []*migrate.Change{
{
Cmd: "CREATE INDEX `b` ON `t1` (`a`)",
Reverse: "DROP INDEX `b`",
},
{
Cmd: "DROP INDEX `a`",
Reverse: "CREATE INDEX `a` ON `t1` (`a`)",
},
},
},
},
// The default is no qualifier.
{
changes: []schema.Change{
&schema.AddTable{T: schema.NewTable("t").SetSchema(schema.New("main")).AddColumns(schema.NewIntColumn("a", "int"))},
},
plan: &migrate.Plan{
Reversible: true,
Transactional: true,
Changes: []*migrate.Change{
{
Cmd: "CREATE TABLE `t` (`a` int NOT NULL)",
Reverse: "DROP TABLE `t`",
},
},
},
},
// Custom qualifier.
{
changes: []schema.Change{
&schema.AddTable{T: schema.NewTable("t").SetSchema(schema.New("d")).AddColumns(schema.NewIntColumn("a", "int"))},
},
options: []migrate.PlanOption{
func(o *migrate.PlanOptions) {
s := "other"
o.SchemaQualifier = &s
},
},
plan: &migrate.Plan{
Reversible: true,
Transactional: true,
Changes: []*migrate.Change{
{
Cmd: "CREATE TABLE `other`.`t` (`a` int NOT NULL)",
Reverse: "DROP TABLE `other`.`t`",
},
},
},
},
}
for i, tt := range tests {
t.Run(strconv.Itoa(i), func(t *testing.T) {
db, mk, err := sqlmock.New()
require.NoError(t, err)
m := mock{mk}
m.systemVars("3.36.0")
if tt.mock != nil {
tt.mock(m)
}
drv, err := Open(db)
require.NoError(t, err)
plan, err := drv.PlanChanges(context.Background(), "plan", tt.changes, tt.options...)
require.NoError(t, err)
require.Equal(t, tt.plan.Reversible, plan.Reversible)
require.Equal(t, tt.plan.Transactional, plan.Transactional)
for i, c := range plan.Changes {
require.Equal(t, tt.plan.Changes[i].Cmd, c.Cmd)
require.Equal(t, tt.plan.Changes[i].Reverse, c.Reverse)
}
})
}
}
atlas-0.7.2/sql/sqlite/sqlitecheck/ 0000775 0000000 0000000 00000000000 14314555116 0017230 5 ustar 00root root 0000000 0000000 atlas-0.7.2/sql/sqlite/sqlitecheck/sqlitecheck.go 0000664 0000000 0000000 00000010041 14314555116 0022052 0 ustar 00root root 0000000 0000000 // Copyright 2021-present The Atlas Authors. All rights reserved.
// This source code is licensed under the Apache 2.0 license found
// in the LICENSE file in the root directory of this source tree.
package sqlitecheck
import (
"context"
"fmt"
"strings"
"ariga.io/atlas/sql/migrate"
"ariga.io/atlas/schemahcl"
"ariga.io/atlas/sql/schema"
"ariga.io/atlas/sql/sqlcheck"
"ariga.io/atlas/sql/sqlcheck/datadepend"
"ariga.io/atlas/sql/sqlcheck/destructive"
"ariga.io/atlas/sql/sqlite"
)
// codeModNotNullC is an SQLite specific code for reporting modifying nullable columns to non-nullable.
var codeModNotNullC = sqlcheck.Code("LT101")
func addNotNull(p *datadepend.ColumnPass) (diags []sqlcheck.Diagnostic, err error) {
tt, err := sqlite.FormatType(p.Column.Type.Type)
if err != nil {
return nil, err
}
return []sqlcheck.Diagnostic{
{
Pos: p.Change.Stmt.Pos,
Text: fmt.Sprintf(
"Adding a non-nullable %q column %q will fail in case table %q is not empty",
tt, p.Column.Name, p.Table.Name,
),
},
}, nil
}
func modifyNotNull(p *datadepend.ColumnPass) (diags []sqlcheck.Diagnostic, err error) {
if p.Column.Default != nil || datadepend.ColumnFilled(p.File, p.Table, p.Column, p.Change.Stmt.Pos) {
return nil, nil
}
return []sqlcheck.Diagnostic{
{
Pos: p.Change.Stmt.Pos,
Code: codeModNotNullC,
Text: fmt.Sprintf("Modifying nullable column %q to non-nullable without default value might fail in case it contains NULL values", p.Column.Name),
},
}, nil
}
func init() {
sqlcheck.Register(sqlite.DriverName, func(r *schemahcl.Resource) ([]sqlcheck.Analyzer, error) {
ds, err := destructive.New(r)
if err != nil {
return nil, err
}
dd, err := datadepend.New(r, datadepend.Handler{
AddNotNull: addNotNull,
ModifyNotNull: modifyNotNull,
})
if err != nil {
return nil, err
}
return []sqlcheck.Analyzer{
sqlcheck.AnalyzerFunc(func(ctx context.Context, p *sqlcheck.Pass) error {
var changes []*sqlcheck.Change
// Detect sequence of changes using temporary table and transform them to one ModifyTable change.
// See: https://www.sqlite.org/lang_altertable.html#making_other_kinds_of_table_schema_changes.
for i := 0; i < len(p.File.Changes); i++ {
if i+3 >= len(p.File.Changes) || !modifyUsingTemp(p.File.Changes[i], p.File.Changes[i+2], p.File.Changes[i+3]) {
changes = append(changes, p.File.Changes[i])
continue
}
prevT, currT := p.File.Changes[i+2].Changes[0].(*schema.DropTable).T, p.File.Changes[i+3].Changes[1].(*schema.AddTable).T
diff, err := p.Dev.Driver.TableDiff(prevT, currT)
if err != nil {
return nil
}
changes = append(changes, &sqlcheck.Change{
Stmt: &migrate.Stmt{
// Use the position of the first statement.
Pos: p.File.Changes[i].Stmt.Pos,
// A combined statement.
Text: strings.Join([]string{
p.File.Changes[i].Stmt.Text,
p.File.Changes[i+2].Stmt.Text,
p.File.Changes[i+3].Stmt.Text,
}, "\n"),
},
Changes: schema.Changes{
&schema.ModifyTable{
T: currT,
Changes: diff,
},
},
})
i += 3
}
p.File.Changes = changes
return nil
}),
ds, dd,
}, nil
})
}
// modifyUsingTemp indicates if the 3 changes represents a table modification using
// the pattern mentioned in the link below: "CREATE", "INSERT", "DROP" and "RENAME".
func modifyUsingTemp(c1, c2, c3 *sqlcheck.Change) bool {
if len(c1.Changes) != 1 || !isAddT(c1.Changes[0], "new_") || len(c2.Changes) != 1 || len(c3.Changes) != 2 {
return false
}
add := c1.Changes[0].(*schema.AddTable)
name := strings.TrimPrefix(add.T.Name, "new_")
// "DROP T" and "RENAME new_T to T".
return isDropT(c2.Changes[0], name) && isDropT(c3.Changes[0], add.T.Name) && isAddT(c3.Changes[1], name)
}
func isAddT(c schema.Change, prefix string) bool {
a, ok := c.(*schema.AddTable)
return ok && strings.HasPrefix(a.T.Name, prefix)
}
func isDropT(c schema.Change, prefix string) bool {
d, ok := c.(*schema.DropTable)
return ok && strings.HasPrefix(d.T.Name, prefix)
}
atlas-0.7.2/sql/sqlite/sqlitecheck/sqlitecheck_test.go 0000664 0000000 0000000 00000010124 14314555116 0023113 0 ustar 00root root 0000000 0000000 // Copyright 2021-present The Atlas Authors. All rights reserved.
// This source code is licensed under the Apache 2.0 license found
// in the LICENSE file in the root directory of this source tree.
package sqlitecheck_test
import (
"context"
"testing"
"ariga.io/atlas/sql/internal/sqlx"
"ariga.io/atlas/sql/migrate"
"ariga.io/atlas/sql/schema"
"ariga.io/atlas/sql/sqlcheck"
"ariga.io/atlas/sql/sqlclient"
"ariga.io/atlas/sql/sqlite"
_ "ariga.io/atlas/sql/sqlite/sqlitecheck"
"github.com/stretchr/testify/require"
)
func TestDetectModifyTable(t *testing.T) {
var (
report *sqlcheck.Report
pass = &sqlcheck.Pass{
Dev: &sqlclient.Client{
Driver: func() migrate.Driver {
drv := &sqlite.Driver{}
drv.Differ = &sqlx.Diff{DiffDriver: &sqlite.Diff{}}
return drv
}(),
},
File: &sqlcheck.File{
File: testFile{name: "1.sql"},
Changes: []*sqlcheck.Change{
// A real drop.
{
Stmt: &migrate.Stmt{
Text: "DROP TABLE `users`",
},
Changes: schema.Changes{
&schema.DropTable{
T: schema.NewTable("users").
SetSchema(schema.New("main")),
},
},
},
// Table modification using a temporary table.
{
Stmt: &migrate.Stmt{
Text: "PRAGMA foreign_keys = off;",
},
},
{
Stmt: &migrate.Stmt{
Text: "CREATE TABLE `new_posts` (`text` text NOT NULL);",
},
Changes: schema.Changes{
&schema.AddTable{
T: schema.NewTable("new_posts").
SetSchema(schema.New("main")).
AddColumns(schema.NewStringColumn("text", "text")),
},
},
},
{
Stmt: &migrate.Stmt{
Text: "INSERT INTO `new_posts` (`text`) SELECT `text` FROM `posts`;",
},
},
{
Stmt: &migrate.Stmt{
Text: "DROP TABLE `posts`",
},
Changes: schema.Changes{
&schema.DropTable{
T: schema.NewTable("posts").
SetSchema(schema.New("main")).
AddColumns(
schema.NewNullStringColumn("text", "text"),
schema.NewTimeColumn("posted_at", "timestamp"),
),
},
},
},
{
Stmt: &migrate.Stmt{
Text: "ALTER TABLE `new_posts` RENAME TO `posts`;",
},
Changes: schema.Changes{
&schema.DropTable{
T: schema.NewTable("new_posts").
SetSchema(schema.New("main")).
AddColumns(schema.NewStringColumn("text", "text")),
},
&schema.AddTable{
T: schema.NewTable("posts").
SetSchema(schema.New("main")).
AddColumns(schema.NewStringColumn("text", "text")),
},
},
},
{
Stmt: &migrate.Stmt{
Text: "PRAGMA foreign_keys = on;",
},
},
// Another real drop.
{
Stmt: &migrate.Stmt{
Text: "DROP TABLE `pets`",
},
Changes: schema.Changes{
&schema.DropTable{
T: schema.NewTable("pets").
SetSchema(schema.New("main")),
},
},
},
},
},
Reporter: sqlcheck.ReportWriterFunc(func(r sqlcheck.Report) {
report = &r
}),
}
)
azs, err := sqlcheck.AnalyzerFor(sqlite.DriverName, nil)
require.NoError(t, err)
require.Len(t, azs, 3)
require.NoError(t, azs[0].Analyze(context.Background(), pass))
err = azs[1].Analyze(context.Background(), pass)
require.EqualError(t, err, "destructive changes detected")
require.Equal(t, report.Text, "destructive changes detected")
require.Len(t, report.Diagnostics, 3)
require.Equal(t, report.Diagnostics[0].Text, `Dropping table "users"`)
require.Equal(t, report.Diagnostics[1].Text, `Dropping non-virtual column "posted_at"`)
require.Equal(t, report.Diagnostics[2].Text, `Dropping table "pets"`)
require.NoError(t, azs[2].Analyze(context.Background(), pass))
require.Equal(t, report.Text, "data dependent changes detected")
require.Len(t, report.Diagnostics, 1)
require.Equal(t, report.Diagnostics[0].Text, `Modifying nullable column "text" to non-nullable without default value might fail in case it contains NULL values`)
}
type testFile struct {
name string
migrate.File
}
func (t testFile) Name() string {
return t.name
}
atlas-0.7.2/sql/sqlite/sqlspec.go 0000664 0000000 0000000 00000021441 14314555116 0016734 0 ustar 00root root 0000000 0000000 // Copyright 2021-present The Atlas Authors. All rights reserved.
// This source code is licensed under the Apache 2.0 license found
// in the LICENSE file in the root directory of this source tree.
package sqlite
import (
"fmt"
"reflect"
"strconv"
"strings"
"ariga.io/atlas/schemahcl"
"ariga.io/atlas/sql/internal/specutil"
"ariga.io/atlas/sql/internal/sqlx"
"ariga.io/atlas/sql/schema"
"ariga.io/atlas/sql/sqlspec"
"github.com/hashicorp/hcl/v2/hclparse"
)
// evalSpec evaluates an Atlas DDL document using an unmarshaler into v by using the input.
func evalSpec(p *hclparse.Parser, v any, input map[string]string) error {
var d doc
if err := hclState.Eval(p, &d, input); err != nil {
return err
}
switch v := v.(type) {
case *schema.Realm:
err := specutil.Scan(v, d.Schemas, d.Tables, convertTable)
if err != nil {
return fmt.Errorf("specutil: failed converting to *schema.Realm: %w", err)
}
case *schema.Schema:
if len(d.Schemas) != 1 {
return fmt.Errorf("specutil: expecting document to contain a single schema, got %d", len(d.Schemas))
}
var r schema.Realm
if err := specutil.Scan(&r, d.Schemas, d.Tables, convertTable); err != nil {
return err
}
r.Schemas[0].Realm = nil
*v = *r.Schemas[0]
default:
return fmt.Errorf("specutil: failed unmarshaling spec. %T is not supported", v)
}
return nil
}
// MarshalSpec marshals v into an Atlas DDL document using a schemahcl.Marshaler.
func MarshalSpec(v any, marshaler schemahcl.Marshaler) ([]byte, error) {
return specutil.Marshal(v, marshaler, schemaSpec)
}
// convertTable converts a sqlspec.Table to a schema.Table. Table conversion is done without converting
// ForeignKeySpecs into ForeignKeys, as the target tables do not necessarily exist in the schema
// at this point. Instead, the linking is done by the convertSchema function.
func convertTable(spec *sqlspec.Table, parent *schema.Schema) (*schema.Table, error) {
return specutil.Table(spec, parent, convertColumn, specutil.PrimaryKey, convertIndex, specutil.Check)
}
// convertIndex converts a sqlspec.Index into a schema.Index.
func convertIndex(spec *sqlspec.Index, t *schema.Table) (*schema.Index, error) {
idx, err := specutil.Index(spec, t)
if err != nil {
return nil, err
}
if attr, ok := spec.Attr("where"); ok {
p, err := attr.String()
if err != nil {
return nil, err
}
idx.Attrs = append(idx.Attrs, &IndexPredicate{P: p})
}
return idx, nil
}
// convertColumn converts a sqlspec.Column into a schema.Column.
func convertColumn(spec *sqlspec.Column, _ *schema.Table) (*schema.Column, error) {
c, err := specutil.Column(spec, convertColumnType)
if err != nil {
return nil, err
}
if attr, ok := spec.Attr("auto_increment"); ok {
b, err := attr.Bool()
if err != nil {
return nil, err
}
if b {
c.AddAttrs(&AutoIncrement{})
}
}
if err := specutil.ConvertGenExpr(spec.Remain(), c, storedOrVirtual); err != nil {
return nil, err
}
return c, nil
}
// convertColumnType converts a sqlspec.Column into a concrete SQLite schema.Type.
func convertColumnType(spec *sqlspec.Column) (schema.Type, error) {
return TypeRegistry.Type(spec.Type, spec.Extra.Attrs)
}
// schemaSpec converts from a concrete SQLite schema to Atlas specification.
func schemaSpec(schem *schema.Schema) (*sqlspec.Schema, []*sqlspec.Table, error) {
return specutil.FromSchema(schem, tableSpec)
}
// tableSpec converts from a concrete SQLite sqlspec.Table to a schema.Table.
func tableSpec(tab *schema.Table) (*sqlspec.Table, error) {
return specutil.FromTable(
tab,
columnSpec,
specutil.FromPrimaryKey,
indexSpec,
specutil.FromForeignKey,
specutil.FromCheck,
)
}
func indexSpec(idx *schema.Index) (*sqlspec.Index, error) {
spec, err := specutil.FromIndex(idx)
if err != nil {
return nil, err
}
if i := (IndexPredicate{}); sqlx.Has(idx.Attrs, &i) && i.P != "" {
spec.Extra.Attrs = append(spec.Extra.Attrs, specutil.VarAttr("where", strconv.Quote(i.P)))
}
return spec, nil
}
// columnSpec converts from a concrete SQLite schema.Column into a sqlspec.Column.
func columnSpec(c *schema.Column, _ *schema.Table) (*sqlspec.Column, error) {
s, err := specutil.FromColumn(c, columnTypeSpec)
if err != nil {
return nil, err
}
if sqlx.Has(c.Attrs, &AutoIncrement{}) {
s.Extra.Attrs = append(s.Extra.Attrs, specutil.BoolAttr("auto_increment", true))
}
if x := (schema.GeneratedExpr{}); sqlx.Has(c.Attrs, &x) {
s.Extra.Children = append(s.Extra.Children, specutil.FromGenExpr(x, storedOrVirtual))
}
return s, nil
}
// columnTypeSpec converts from a concrete MySQL schema.Type into sqlspec.Column Type.
func columnTypeSpec(t schema.Type) (*sqlspec.Column, error) {
st, err := TypeRegistry.Convert(t)
if err != nil {
return nil, err
}
return &sqlspec.Column{Type: st}, nil
}
// TypeRegistry contains the supported TypeSpecs for the sqlite driver.
var TypeRegistry = schemahcl.NewRegistry(
schemahcl.WithFormatter(FormatType),
schemahcl.WithParser(ParseType),
schemahcl.WithSpecs(
schemahcl.NewTypeSpec(TypeReal, schemahcl.WithAttributes(&schemahcl.TypeAttr{Name: "precision", Kind: reflect.Int, Required: false}, &schemahcl.TypeAttr{Name: "scale", Kind: reflect.Int, Required: false})),
schemahcl.NewTypeSpec(TypeBlob, schemahcl.WithAttributes(schemahcl.SizeTypeAttr(false))),
schemahcl.NewTypeSpec(TypeText, schemahcl.WithAttributes(schemahcl.SizeTypeAttr(false))),
schemahcl.NewTypeSpec(TypeInteger, schemahcl.WithAttributes(schemahcl.SizeTypeAttr(false))),
schemahcl.NewTypeSpec("int", schemahcl.WithAttributes(schemahcl.SizeTypeAttr(false))),
schemahcl.NewTypeSpec("tinyint", schemahcl.WithAttributes(schemahcl.SizeTypeAttr(false))),
schemahcl.NewTypeSpec("smallint", schemahcl.WithAttributes(schemahcl.SizeTypeAttr(false))),
schemahcl.NewTypeSpec("mediumint", schemahcl.WithAttributes(schemahcl.SizeTypeAttr(false))),
schemahcl.NewTypeSpec("bigint", schemahcl.WithAttributes(schemahcl.SizeTypeAttr(false))),
schemahcl.AliasTypeSpec("unsigned_big_int", "unsigned big int", schemahcl.WithAttributes(schemahcl.SizeTypeAttr(false))),
schemahcl.NewTypeSpec("int2", schemahcl.WithAttributes(schemahcl.SizeTypeAttr(false))),
schemahcl.NewTypeSpec("int8", schemahcl.WithAttributes(schemahcl.SizeTypeAttr(false))),
schemahcl.NewTypeSpec("double", schemahcl.WithAttributes(schemahcl.SizeTypeAttr(false))),
schemahcl.AliasTypeSpec("double_precision", "double precision", schemahcl.WithAttributes(schemahcl.SizeTypeAttr(false))),
schemahcl.NewTypeSpec("float", schemahcl.WithAttributes(schemahcl.SizeTypeAttr(false))),
schemahcl.NewTypeSpec("character", schemahcl.WithAttributes(schemahcl.SizeTypeAttr(false))),
schemahcl.NewTypeSpec("varchar", schemahcl.WithAttributes(schemahcl.SizeTypeAttr(false))),
schemahcl.AliasTypeSpec("varying_character", "varying character", schemahcl.WithAttributes(schemahcl.SizeTypeAttr(false))),
schemahcl.NewTypeSpec("nchar", schemahcl.WithAttributes(schemahcl.SizeTypeAttr(false))),
schemahcl.AliasTypeSpec("native_character", "native character", schemahcl.WithAttributes(schemahcl.SizeTypeAttr(false))),
schemahcl.NewTypeSpec("nvarchar", schemahcl.WithAttributes(schemahcl.SizeTypeAttr(false))),
schemahcl.NewTypeSpec("clob", schemahcl.WithAttributes(schemahcl.SizeTypeAttr(false))),
schemahcl.NewTypeSpec("numeric", schemahcl.WithAttributes(&schemahcl.TypeAttr{Name: "precision", Kind: reflect.Int, Required: false}, &schemahcl.TypeAttr{Name: "scale", Kind: reflect.Int, Required: false})),
schemahcl.NewTypeSpec("decimal", schemahcl.WithAttributes(&schemahcl.TypeAttr{Name: "precision", Kind: reflect.Int, Required: false}, &schemahcl.TypeAttr{Name: "scale", Kind: reflect.Int, Required: false})),
schemahcl.NewTypeSpec("bool"),
schemahcl.NewTypeSpec("boolean"),
schemahcl.NewTypeSpec("date"),
schemahcl.NewTypeSpec("datetime"),
schemahcl.NewTypeSpec("json"),
schemahcl.NewTypeSpec("uuid"),
),
)
var (
hclState = schemahcl.New(
schemahcl.WithTypes(TypeRegistry.Specs()),
schemahcl.WithScopedEnums("table.column.as.type", stored, virtual),
schemahcl.WithScopedEnums("table.foreign_key.on_update", specutil.ReferenceVars...),
schemahcl.WithScopedEnums("table.foreign_key.on_delete", specutil.ReferenceVars...),
)
// MarshalHCL marshals v into an Atlas HCL DDL document.
MarshalHCL = schemahcl.MarshalerFunc(func(v any) ([]byte, error) {
return MarshalSpec(v, hclState)
})
// EvalHCL implements the schemahcl.Evaluator interface.
EvalHCL = schemahcl.EvalFunc(evalSpec)
// EvalHCLBytes is a helper that evaluates an HCL document from a byte slice instead
// of from an hclparse.Parser instance.
EvalHCLBytes = specutil.HCLBytesFunc(EvalHCL)
)
// storedOrVirtual returns a STORED or VIRTUAL
// generated type option based on the given string.
func storedOrVirtual(s string) string {
if s = strings.ToUpper(s); s == "" {
return virtual
}
return s
}
type doc struct {
Tables []*sqlspec.Table `spec:"table"`
Schemas []*sqlspec.Schema `spec:"schema"`
}
atlas-0.7.2/sql/sqlite/sqlspec_test.go 0000664 0000000 0000000 00000020430 14314555116 0017770 0 ustar 00root root 0000000 0000000 // Copyright 2021-present The Atlas Authors. All rights reserved.
// This source code is licensed under the Apache 2.0 license found
// in the LICENSE file in the root directory of this source tree.
package sqlite
import (
"fmt"
"testing"
"ariga.io/atlas/sql/internal/spectest"
"ariga.io/atlas/sql/schema"
"github.com/stretchr/testify/require"
)
func TestSQLSpec(t *testing.T) {
f := `
schema "schema" {
}
table "table" {
schema = schema.schema
column "id" {
type = integer
auto_increment = true
}
column "age" {
type = integer
}
column "price" {
type = integer
}
column "account_name" {
type = varchar(32)
}
primary_key {
columns = [table.table.column.id]
}
index "index" {
unique = true
columns = [
table.table.column.id,
table.table.column.age,
]
where = "age <> 0"
}
foreign_key "accounts" {
columns = [
table.table.column.account_name,
]
ref_columns = [
table.accounts.column.name,
]
on_delete = SET_NULL
}
check "positive price" {
expr = "price > 0"
}
}
table "accounts" {
schema = schema.schema
column "name" {
type = varchar(32)
}
primary_key {
columns = [table.accounts.column.name]
}
}
`
exp := &schema.Schema{
Name: "schema",
}
exp.Tables = []*schema.Table{
{
Name: "table",
Schema: exp,
Columns: []*schema.Column{
{
Name: "id",
Type: &schema.ColumnType{
Type: &schema.IntegerType{
T: "integer",
},
},
Attrs: []schema.Attr{
&AutoIncrement{},
},
},
{
Name: "age",
Type: &schema.ColumnType{
Type: &schema.IntegerType{
T: "integer",
},
},
},
{
Name: "price",
Type: &schema.ColumnType{
Type: &schema.IntegerType{
T: "integer",
},
},
},
{
Name: "account_name",
Type: &schema.ColumnType{
Type: &schema.StringType{
T: "varchar",
Size: 32,
},
},
},
},
Attrs: []schema.Attr{
&schema.Check{
Name: "positive price",
Expr: "price > 0",
},
},
},
{
Name: "accounts",
Schema: exp,
Columns: []*schema.Column{
{
Name: "name",
Type: &schema.ColumnType{
Type: &schema.StringType{
T: "varchar",
Size: 32,
},
},
},
},
},
}
exp.Tables[0].PrimaryKey = &schema.Index{
Table: exp.Tables[0],
Parts: []*schema.IndexPart{
{SeqNo: 0, C: exp.Tables[0].Columns[0]},
},
}
exp.Tables[0].Indexes = []*schema.Index{
{
Name: "index",
Table: exp.Tables[0],
Unique: true,
Parts: []*schema.IndexPart{
{SeqNo: 0, C: exp.Tables[0].Columns[0]},
{SeqNo: 1, C: exp.Tables[0].Columns[1]},
},
Attrs: []schema.Attr{
&IndexPredicate{P: "age <> 0"},
},
},
}
exp.Tables[0].ForeignKeys = []*schema.ForeignKey{
{
Symbol: "accounts",
Table: exp.Tables[0],
Columns: []*schema.Column{exp.Tables[0].Columns[3]},
RefTable: exp.Tables[1],
RefColumns: []*schema.Column{exp.Tables[1].Columns[0]},
OnDelete: schema.SetNull,
},
}
exp.Tables[1].PrimaryKey = &schema.Index{
Table: exp.Tables[1],
Parts: []*schema.IndexPart{
{SeqNo: 0, C: exp.Tables[1].Columns[0]},
},
}
var s schema.Schema
err := EvalHCLBytes([]byte(f), &s, nil)
require.NoError(t, err)
require.EqualValues(t, exp, &s)
}
func TestMarshalSpec_AutoIncrement(t *testing.T) {
s := &schema.Schema{
Name: "test",
Tables: []*schema.Table{
{
Name: "users",
Columns: []*schema.Column{
{
Name: "id",
Type: &schema.ColumnType{Type: &schema.IntegerType{T: "int"}},
Attrs: []schema.Attr{
&AutoIncrement{},
},
},
},
},
},
}
s.Tables[0].Schema = s
buf, err := MarshalSpec(s, hclState)
require.NoError(t, err)
const expected = `table "users" {
schema = schema.test
column "id" {
null = false
type = int
auto_increment = true
}
}
schema "test" {
}
`
require.EqualValues(t, expected, string(buf))
}
func TestMarshalSpec_IndexPredicate(t *testing.T) {
s := &schema.Schema{
Name: "test",
Tables: []*schema.Table{
{
Name: "users",
Columns: []*schema.Column{
{
Name: "id",
Type: &schema.ColumnType{Type: &schema.IntegerType{T: "int"}},
Attrs: []schema.Attr{
&AutoIncrement{},
},
},
},
},
},
}
s.Tables[0].Schema = s
s.Tables[0].Schema = s
s.Tables[0].Indexes = []*schema.Index{
{
Name: "index",
Table: s.Tables[0],
Unique: true,
Parts: []*schema.IndexPart{
{SeqNo: 0, C: s.Tables[0].Columns[0]},
},
Attrs: []schema.Attr{
&IndexPredicate{P: "id <> 0"},
},
},
}
buf, err := MarshalSpec(s, hclState)
require.NoError(t, err)
const expected = `table "users" {
schema = schema.test
column "id" {
null = false
type = int
auto_increment = true
}
index "index" {
unique = true
columns = [column.id]
where = "id <> 0"
}
}
schema "test" {
}
`
require.EqualValues(t, expected, string(buf))
}
func TestTypes(t *testing.T) {
for _, tt := range []struct {
typeExpr string
expected schema.Type
}{
{
typeExpr: "integer(10)",
expected: &schema.IntegerType{T: "integer"},
},
{
typeExpr: "int(10)",
expected: &schema.IntegerType{T: "int"},
},
{
typeExpr: `sql("custom")`,
expected: &schema.UnsupportedType{T: "custom"},
},
{
typeExpr: "tinyint(10)",
expected: &schema.IntegerType{T: "tinyint"},
},
{
typeExpr: "smallint(10)",
expected: &schema.IntegerType{T: "smallint"},
},
{
typeExpr: "mediumint(10)",
expected: &schema.IntegerType{T: "mediumint"},
},
{
typeExpr: "bigint(10)",
expected: &schema.IntegerType{T: "bigint"},
},
{
typeExpr: "unsigned_big_int(10)",
expected: &schema.IntegerType{T: "unsigned big int"},
},
{
typeExpr: "int2(10)",
expected: &schema.IntegerType{T: "int2"},
},
{
typeExpr: "int8(10)",
expected: &schema.IntegerType{T: "int8"},
},
{
typeExpr: "real",
expected: &schema.FloatType{T: "real"},
},
{
typeExpr: "double",
expected: &schema.FloatType{T: "double"},
},
{
typeExpr: "double_precision",
expected: &schema.FloatType{T: "double precision"},
},
{
typeExpr: "float(10)",
expected: &schema.FloatType{T: "float"},
},
{
typeExpr: "text(10)",
expected: &schema.StringType{T: "text", Size: 10},
},
{
typeExpr: "character(10)",
expected: &schema.StringType{T: "character", Size: 10},
},
{
typeExpr: "varchar(10)",
expected: &schema.StringType{T: "varchar", Size: 10},
},
{
typeExpr: "varying_character",
expected: &schema.StringType{T: "varying character"},
},
{
typeExpr: "nchar(10)",
expected: &schema.StringType{T: "nchar", Size: 10},
},
{
typeExpr: "native_character",
expected: &schema.StringType{T: "native character"},
},
{
typeExpr: "nvarchar(10)",
expected: &schema.StringType{T: "nvarchar", Size: 10},
},
{
typeExpr: "clob(10)",
expected: &schema.StringType{T: "clob", Size: 10},
},
{
typeExpr: "blob(10)",
expected: &schema.BinaryType{T: "blob"},
},
{
typeExpr: "numeric(10)",
expected: &schema.DecimalType{T: "numeric", Precision: 10},
},
{
typeExpr: "decimal(10,5)",
expected: &schema.DecimalType{T: "decimal", Precision: 10, Scale: 5},
},
{
typeExpr: "boolean",
expected: &schema.BoolType{T: "boolean"},
},
{
typeExpr: "date",
expected: &schema.TimeType{T: "date"},
},
{
typeExpr: "datetime",
expected: &schema.TimeType{T: "datetime"},
},
{
typeExpr: "json",
expected: &schema.JSONType{T: "json"},
},
{
typeExpr: "uuid",
expected: &UUIDType{T: "uuid"},
},
} {
t.Run(tt.typeExpr, func(t *testing.T) {
var test schema.Schema
doc := fmt.Sprintf(`table "test" {
schema = schema.test
column "test" {
null = false
type = %s
}
}
schema "test" {
}
`, tt.typeExpr)
err := EvalHCLBytes([]byte(doc), &test, nil)
require.NoError(t, err)
colspec := test.Tables[0].Columns[0]
require.EqualValues(t, tt.expected, colspec.Type.Type)
spec, err := MarshalSpec(&test, hclState)
require.NoError(t, err)
var after schema.Schema
err = EvalHCLBytes(spec, &after, nil)
require.NoError(t, err)
require.EqualValues(t, tt.expected, after.Tables[0].Columns[0].Type.Type)
})
}
}
func TestInputVars(t *testing.T) {
spectest.TestInputVars(t, EvalHCL)
}
atlas-0.7.2/sql/sqlspec/ 0000775 0000000 0000000 00000000000 14314555116 0015102 5 ustar 00root root 0000000 0000000 atlas-0.7.2/sql/sqlspec/sqlspec.go 0000664 0000000 0000000 00000004764 14314555116 0017116 0 ustar 00root root 0000000 0000000 // Copyright 2021-present The Atlas Authors. All rights reserved.
// This source code is licensed under the Apache 2.0 license found
// in the LICENSE file in the root directory of this source tree.
package sqlspec
import (
"ariga.io/atlas/schemahcl"
)
type (
// Schema holds a specification for a Schema.
Schema struct {
Name string `spec:"name,name"`
schemahcl.DefaultExtension
}
// Table holds a specification for an SQL table.
Table struct {
Name string `spec:",name"`
Qualifier string `spec:",qualifier"`
Schema *schemahcl.Ref `spec:"schema"`
Columns []*Column `spec:"column"`
PrimaryKey *PrimaryKey `spec:"primary_key"`
ForeignKeys []*ForeignKey `spec:"foreign_key"`
Indexes []*Index `spec:"index"`
Checks []*Check `spec:"check"`
schemahcl.DefaultExtension
}
// Column holds a specification for a column in an SQL table.
Column struct {
Name string `spec:",name"`
Null bool `spec:"null"`
Type *schemahcl.Type `spec:"type"`
Default schemahcl.Value `spec:"default"`
schemahcl.DefaultExtension
}
// PrimaryKey holds a specification for the primary key of a table.
PrimaryKey struct {
Columns []*schemahcl.Ref `spec:"columns"`
schemahcl.DefaultExtension
}
// Index holds a specification for the index key of a table.
Index struct {
Name string `spec:",name"`
Unique bool `spec:"unique,omitempty"`
Parts []*IndexPart `spec:"on"`
Columns []*schemahcl.Ref `spec:"columns"`
schemahcl.DefaultExtension
}
// IndexPart holds a specification for the index key part.
IndexPart struct {
Desc bool `spec:"desc,omitempty"`
Column *schemahcl.Ref `spec:"column"`
Expr string `spec:"expr,omitempty"`
schemahcl.DefaultExtension
}
// Check holds a specification for a check constraint on a table.
Check struct {
Name string `spec:",name"`
Expr string `spec:"expr"`
schemahcl.DefaultExtension
}
// ForeignKey holds a specification for the Foreign key of a table.
ForeignKey struct {
Symbol string `spec:",name"`
Columns []*schemahcl.Ref `spec:"columns"`
RefColumns []*schemahcl.Ref `spec:"ref_columns"`
OnUpdate *schemahcl.Ref `spec:"on_update"`
OnDelete *schemahcl.Ref `spec:"on_delete"`
schemahcl.DefaultExtension
}
// Type represents a database agnostic column type.
Type string
)
func init() {
schemahcl.Register("table", &Table{})
schemahcl.Register("schema", &Schema{})
}
atlas-0.7.2/sql/sqltool/ 0000775 0000000 0000000 00000000000 14314555116 0015125 5 ustar 00root root 0000000 0000000 atlas-0.7.2/sql/sqltool/doc.go 0000664 0000000 0000000 00000000503 14314555116 0016217 0 ustar 00root root 0000000 0000000 // Copyright 2021-present The Atlas Authors. All rights reserved.
// This source code is licensed under the Apache 2.0 license found
// in the LICENSE file in the root directory of this source tree.
// Package sqltool contains logic to integrate existing tools like Flyway or Liquibase with the Atlas CLI.
package sqltool
atlas-0.7.2/sql/sqltool/hidden.go 0000664 0000000 0000000 00000000534 14314555116 0016711 0 ustar 00root root 0000000 0000000 // Copyright 2021-present The Atlas Authors. All rights reserved.
// This source code is licensed under the Apache 2.0 license found
// in the LICENSE file in the root directory of this source tree.
//go:build !windows
package sqltool
import "path/filepath"
func hidden(path string) (bool, error) {
return filepath.Base(path)[0] == '.', nil
}
atlas-0.7.2/sql/sqltool/hidden_windows.go 0000664 0000000 0000000 00000001117 14314555116 0020461 0 ustar 00root root 0000000 0000000 // Copyright 2021-present The Atlas Authors. All rights reserved.
// This source code is licensed under the Apache 2.0 license found
// in the LICENSE file in the root directory of this source tree.
package sqltool
import (
"path/filepath"
"syscall"
)
func hidden(path string) (bool, error) {
abs, err := filepath.Abs(path)
if err != nil {
return false, err
}
p, err := syscall.UTF16PtrFromString(abs)
if err != nil {
return false, err
}
attr, err := syscall.GetFileAttributes(p)
if err != nil {
return false, err
}
return attr&syscall.FILE_ATTRIBUTE_HIDDEN != 0, nil
}
atlas-0.7.2/sql/sqltool/testdata/ 0000775 0000000 0000000 00000000000 14314555116 0016736 5 ustar 00root root 0000000 0000000 atlas-0.7.2/sql/sqltool/testdata/dbmate/ 0000775 0000000 0000000 00000000000 14314555116 0020172 5 ustar 00root root 0000000 0000000 atlas-0.7.2/sql/sqltool/testdata/dbmate/1_initial.sql 0000664 0000000 0000000 00000000453 14314555116 0022566 0 ustar 00root root 0000000 0000000 -- migrate:up
CREATE TABLE post
(
id int NOT NULL,
title text,
body text,
PRIMARY KEY (id)
);
/*
Multiline comment ...
*/
ALTER TABLE post ADD created_at TIMESTAMP NOT NULL;
INSERT INTO post (title) VALUES (
'This is
my multiline
value');
-- migrate:down
DROP TABLE post; atlas-0.7.2/sql/sqltool/testdata/dbmate/2_second_migration.sql 0000664 0000000 0000000 00000000062 14314555116 0024456 0 ustar 00root root 0000000 0000000
-- migrate:up
CREATE TABLE tbl_2 (col INT); atlas-0.7.2/sql/sqltool/testdata/flyway/ 0000775 0000000 0000000 00000000000 14314555116 0020251 5 ustar 00root root 0000000 0000000 atlas-0.7.2/sql/sqltool/testdata/flyway/B2__baseline.sql 0000664 0000000 0000000 00000000333 14314555116 0023235 0 ustar 00root root 0000000 0000000 CREATE TABLE post
(
id int NOT NULL,
title text,
body text,
created_at TIMESTAMP NOT NULL
PRIMARY KEY (id)
);
INSERT INTO post (title, created_at) VALUES (
'This is
my multiline
value', NOW()); atlas-0.7.2/sql/sqltool/testdata/flyway/R__views.sql 0000664 0000000 0000000 00000000056 14314555116 0022550 0 ustar 00root root 0000000 0000000 CREATE VIEW `my_view` AS SELECT * FROM `post`; atlas-0.7.2/sql/sqltool/testdata/flyway/U1__initial.sql 0000664 0000000 0000000 00000000017 14314555116 0023125 0 ustar 00root root 0000000 0000000 DROP TABLE tbl; atlas-0.7.2/sql/sqltool/testdata/flyway/V1__initial.sql 0000664 0000000 0000000 00000000372 14314555116 0023132 0 ustar 00root root 0000000 0000000 -- comment
CREATE TABLE post
(
id int NOT NULL,
title text,
body text,
PRIMARY KEY (id)
);
ALTER TABLE post ADD created_at TIMESTAMP NOT NULL;
INSERT INTO post (title, created_at) VALUES (
'This is
my multiline
value', NOW());
atlas-0.7.2/sql/sqltool/testdata/flyway/V2__second_migration.sql 0000664 0000000 0000000 00000000062 14314555116 0025022 0 ustar 00root root 0000000 0000000
-- migrate:up
CREATE TABLE tbl_2 (col INT); atlas-0.7.2/sql/sqltool/testdata/flyway/V3__third_migration.sql 0000664 0000000 0000000 00000000055 14314555116 0024664 0 ustar 00root root 0000000 0000000 ALTER TABLE tbl_2 ADD col_1 INTEGER NOT NULL; atlas-0.7.2/sql/sqltool/testdata/golang-migrate/ 0000775 0000000 0000000 00000000000 14314555116 0021633 5 ustar 00root root 0000000 0000000 atlas-0.7.2/sql/sqltool/testdata/golang-migrate/1_initial.down.sql 0000664 0000000 0000000 00000000017 14314555116 0025171 0 ustar 00root root 0000000 0000000 DROP TABLE tbl; atlas-0.7.2/sql/sqltool/testdata/golang-migrate/1_initial.up.sql 0000664 0000000 0000000 00000000041 14314555116 0024643 0 ustar 00root root 0000000 0000000 CREATE TABLE tbl
(
col INT
); atlas-0.7.2/sql/sqltool/testdata/golang-migrate/2_second_migration.down.sql 0000664 0000000 0000000 00000000021 14314555116 0027060 0 ustar 00root root 0000000 0000000 DROP TABLE tbl_2; atlas-0.7.2/sql/sqltool/testdata/golang-migrate/2_second_migration.up.sql 0000664 0000000 0000000 00000000035 14314555116 0026542 0 ustar 00root root 0000000 0000000 CREATE TABLE tbl_2 (col INT); atlas-0.7.2/sql/sqltool/testdata/goose/ 0000775 0000000 0000000 00000000000 14314555116 0020052 5 ustar 00root root 0000000 0000000 atlas-0.7.2/sql/sqltool/testdata/goose/1_initial.sql 0000664 0000000 0000000 00000000411 14314555116 0022440 0 ustar 00root root 0000000 0000000 -- +goose Up
CREATE TABLE post
(
id int NOT NULL,
title text,
body text,
PRIMARY KEY (id)
);
ALTER TABLE post ADD created_at TIMESTAMP NOT NULL;
INSERT INTO post (title) VALUES (
'This is
my multiline
value');
-- +goose Down
DROP TABLE post; atlas-0.7.2/sql/sqltool/testdata/goose/2_second_migration.sql 0000664 0000000 0000000 00000001437 14314555116 0024345 0 ustar 00root root 0000000 0000000
-- +goose Up
ALTER TABLE post ADD updated_at TIMESTAMP NOT NULL;
-- +goose StatementBegin
-- Comment for the function declaration.
CREATE
OR REPLACE FUNCTION histories_partition_creation( DATE, DATE )
returns void AS $$
DECLARE
create_query text;
BEGIN
FOR create_query IN
SELECT 'CREATE TABLE IF NOT EXISTS histories_'
|| TO_CHAR(d, 'YYYY_MM')
|| ' ( CHECK( created_at >= timestamp '''
|| TO_CHAR(d, 'YYYY-MM-DD 00:00:00')
|| ''' AND created_at < timestamp '''
|| TO_CHAR(d + INTERVAL '1 month', 'YYYY-MM-DD 00:00:00')
|| ''' ) ) inherits ( histories );'
FROM generate_series($1, $2, '1 month') AS d LOOP
EXECUTE create_query;
END LOOP; -- LOOP END
END; -- FUNCTION END
$$
language plpgsql;
-- +goose StatementEnd atlas-0.7.2/sql/sqltool/testdata/liquibase/ 0000775 0000000 0000000 00000000000 14314555116 0020714 5 ustar 00root root 0000000 0000000 atlas-0.7.2/sql/sqltool/testdata/liquibase/1_initial.sql 0000664 0000000 0000000 00000000604 14314555116 0023306 0 ustar 00root root 0000000 0000000 --liquibase formatted sql
--changeset atlas:1-1
CREATE TABLE post
(
id int NOT NULL,
title text,
body text,
PRIMARY KEY (id)
);
--rollback: DROP TABLE post;
--changeset atlas:1-2
ALTER TABLE post ADD created_at TIMESTAMP NOT NULL;
--rollback: ALTER TABLE post DROP created_at;
--changeset atlas:1-3
INSERT INTO post (title) VALUES (
'This is
my multiline
value');
atlas-0.7.2/sql/sqltool/testdata/liquibase/2_second_migration.sql 0000664 0000000 0000000 00000000154 14314555116 0025202 0 ustar 00root root 0000000 0000000 --liquibase formatted sql
--changeset atlas:2-1
CREATE TABLE tbl_2 (col INT);
--rollback DROP TABLE tbl_2;
atlas-0.7.2/sql/sqltool/tool.go 0000664 0000000 0000000 00000037660 14314555116 0016445 0 ustar 00root root 0000000 0000000 // Copyright 2021-present The Atlas Authors. All rights reserved.
// This source code is licensed under the Apache 2.0 license found
// in the LICENSE file in the root directory of this source tree.
package sqltool
import (
"bufio"
"bytes"
"fmt"
"io/fs"
"path/filepath"
"regexp"
"sort"
"strings"
"text/template"
"time"
"unicode"
"ariga.io/atlas/sql/migrate"
)
var (
// GolangMigrateFormatter returns migrate.Formatter compatible with golang-migrate/migrate.
GolangMigrateFormatter = templateFormatter(
"{{ now }}{{ with .Name }}_{{ . }}{{ end }}.up.sql",
`{{ range .Changes }}{{ with .Comment }}-- {{ println . }}{{ end }}{{ printf "%s;\n" .Cmd }}{{ end }}`,
"{{ now }}{{ with .Name }}_{{ . }}{{ end }}.down.sql",
`{{ range rev .Changes }}{{ if .Reverse }}{{ with .Comment }}-- reverse: {{ println . }}{{ end }}{{ printf "%s;\n" .Reverse }}{{ end }}{{ end }}`,
)
// GooseFormatter returns migrate.Formatter compatible with pressly/goose.
GooseFormatter = templateFormatter(
"{{ now }}{{ with .Name }}_{{ . }}{{ end }}.sql",
`-- +goose Up
{{ range .Changes }}{{ with .Comment }}-- {{ println . }}{{ end }}{{ printf "%s;\n" .Cmd }}{{ end }}
-- +goose Down
{{ range rev .Changes }}{{ if .Reverse }}{{ with .Comment }}-- reverse: {{ println . }}{{ end }}{{ printf "%s;\n" .Reverse }}{{ end }}{{ end }}`,
)
// FlywayFormatter returns migrate.Formatter compatible with Flyway.
FlywayFormatter = templateFormatter(
"V{{ now }}{{ with .Name }}__{{ . }}{{ end }}.sql",
`{{ range .Changes }}{{ with .Comment }}-- {{ println . }}{{ end }}{{ printf "%s;\n" .Cmd }}{{ end }}`,
"U{{ now }}{{ with .Name }}__{{ . }}{{ end }}.sql",
`{{ range rev .Changes }}{{ if .Reverse }}{{ with .Comment }}-- reverse: {{ println . }}{{ end }}{{ printf "%s;\n" .Reverse }}{{ end }}{{ end }}`,
)
// LiquibaseFormatter returns migrate.Formatter compatible with Liquibase.
LiquibaseFormatter = templateFormatter(
"{{ now }}{{ with .Name }}_{{ . }}{{ end }}.sql",
`{{- $now := now -}}
--liquibase formatted sql
{{- range $index, $change := .Changes }}
--changeset atlas:{{ $now }}-{{ inc $index }}
{{ with $change.Comment }}--comment: {{ . }}{{ end }}
{{ $change.Cmd }};
{{ with $change.Reverse }}--rollback: {{ . }};{{ end }}
{{ end }}`,
)
// DBMateFormatter returns migrate.Formatter compatible with amacneil/dbmate.
DBMateFormatter = templateFormatter(
"{{ now }}{{ with .Name }}_{{ . }}{{ end }}.sql",
`-- migrate:up
{{ range .Changes }}{{ with .Comment }}-- {{ println . }}{{ end }}{{ printf "%s;\n" .Cmd }}{{ end }}
-- migrate:down
{{ range rev .Changes }}{{ if .Reverse }}{{ with .Comment }}-- reverse: {{ println . }}{{ end }}{{ printf "%s;\n" .Reverse }}{{ end }}{{ end }}`,
)
// DbmateFormatter is the same as DBMateFormatter.
// Deprecated: Use DBMateFormatter instead.
DbmateFormatter = DBMateFormatter
)
type (
// GolangMigrateDir wraps migrate.LocalDir and provides a migrate.Scanner implementation able to understand files
// generated by the GolangMigrateFormatter for migration directory replaying.
GolangMigrateDir struct{ *migrate.LocalDir }
// GolangMigrateFile wraps migrate.LocalFile with custom description function.
GolangMigrateFile struct{ *migrate.LocalFile }
)
// NewGolangMigrateDir returns a new GolangMigrateDir.
func NewGolangMigrateDir(path string) (*GolangMigrateDir, error) {
dir, err := migrate.NewLocalDir(path)
if err != nil {
return nil, err
}
return &GolangMigrateDir{dir}, nil
}
// Files implements Scanner.Files. It looks for all files with up.sql suffix and orders them by filename.
func (d *GolangMigrateDir) Files() ([]migrate.File, error) {
names, err := fs.Glob(d, "*.up.sql")
if err != nil {
return nil, err
}
// Sort files lexicographically.
sort.Slice(names, func(i, j int) bool {
return names[i] < names[j]
})
ret := make([]migrate.File, len(names))
for i, n := range names {
b, err := fs.ReadFile(d, n)
if err != nil {
return nil, fmt.Errorf("sql/migrate: read file %q: %w", n, err)
}
ret[i] = &GolangMigrateFile{LocalFile: migrate.NewLocalFile(n, b)}
}
return ret, nil
}
// Desc implements File.Desc.
func (f *GolangMigrateFile) Desc() string {
return strings.TrimSuffix(f.LocalFile.Desc(), ".up")
}
type (
// GooseDir wraps migrate.LocalDir and provides a migrate.Scanner implementation able to understand files
// generated by the GooseFormatter for migration directory replaying.
GooseDir struct{ *migrate.LocalDir }
// GooseFile wraps migrate.LocalFile with custom statements function.
GooseFile struct{ *migrate.LocalFile }
)
// NewGooseDir returns a new GooseDir.
func NewGooseDir(path string) (*GooseDir, error) {
dir, err := migrate.NewLocalDir(path)
if err != nil {
return nil, err
}
return &GooseDir{dir}, nil
}
// Files looks for all files with .sql suffix and orders them by filename.
func (d *GooseDir) Files() ([]migrate.File, error) {
files, err := d.LocalDir.Files()
if err != nil {
return nil, err
}
for i, f := range files {
files[i] = &GooseFile{f.(*migrate.LocalFile)}
}
return files, nil
}
// StmtDecls understands the migration format used by pressly/goose sql migration files.
func (f *GooseFile) StmtDecls() ([]*migrate.Stmt, error) {
// Atlas custom delimiter is per file, goose has pragma do mark start and end of a delimiter.
// In order to use the Atlas lexer, we define a custom delimiter for the source SQL and edit it to use the
// custom delimiter.
const delim = "-- ATLAS_DELIM_END"
var (
state, lineCount int
lines = []string{"-- atlas:delimiter " + delim, ""}
sc = bufio.NewScanner(bytes.NewReader(f.Bytes()))
)
Scan:
for sc.Scan() {
lineCount++
line := sc.Text()
// Handle goose custom delimiters.
if strings.HasPrefix(line, goosePragma) {
switch strings.TrimSpace(strings.TrimPrefix(line, goosePragma)) {
case "Up":
switch state {
case none: // found the "up" part of the file
state = up
default:
return nil, unexpectedPragmaErr(f, lineCount, "Up")
}
case "Down":
switch state {
case up: // found the "down" part
break Scan
default:
return nil, unexpectedPragmaErr(f, lineCount, "Down")
}
case "StatementBegin":
switch state {
case up:
state = begin // begin of a statement
default:
return nil, unexpectedPragmaErr(f, lineCount, "StatementBegin")
}
case "StatementEnd":
switch state {
case begin:
state = end // end of a statement
default:
return nil, unexpectedPragmaErr(f, lineCount, "StatementEnd")
}
}
}
// Write the line of the statement.
if !reGoosePragma.MatchString(line) && state != end {
// end of statement if line ends with semicolon
line = strings.TrimRightFunc(line, unicode.IsSpace)
lines = append(lines, line)
if state == up && strings.HasSuffix(line, ";") && !strings.HasPrefix(line, "--") {
lines = append(lines, delim)
}
}
if state == end {
state = up
lines = append(lines, delim)
}
}
return migrate.Stmts(strings.Join(lines, "\n"))
}
// Stmts understands the migration format used by pressly/goose sql migration files.
func (f *GooseFile) Stmts() ([]string, error) {
s, err := f.StmtDecls()
if err != nil {
return nil, err
}
stmts := make([]string, len(s))
for i := range s {
stmts[i] = s[i].Text
}
return stmts, nil
}
type (
// DBMateDir wraps migrate.LocalDir and provides a migrate.Scanner implementation able to understand files
// generated by the DBMateFormatter for migration directory replaying.
DBMateDir struct{ *migrate.LocalDir }
// DBMateFile wraps migrate.LocalFile with custom statements function.
DBMateFile struct{ *migrate.LocalFile }
)
// NewDBMateDir returns a new DBMateDir.
func NewDBMateDir(path string) (*DBMateDir, error) {
dir, err := migrate.NewLocalDir(path)
if err != nil {
return nil, err
}
return &DBMateDir{dir}, nil
}
// Files looks for all files with up.sql suffix and orders them by filename.
func (d *DBMateDir) Files() ([]migrate.File, error) {
files, err := d.LocalDir.Files()
if err != nil {
return nil, err
}
for i, f := range files {
files[i] = &DBMateFile{f.(*migrate.LocalFile)}
}
return files, nil
}
// StmtDecls understands the migration format used by amacneil/dbmate sql migration files.
func (f *DBMateFile) StmtDecls() ([]*migrate.Stmt, error) {
var (
state, lineCount int
lines []string
sc = bufio.NewScanner(bytes.NewReader(f.Bytes()))
)
Scan:
for sc.Scan() {
lineCount++
line := sc.Text()
// Handle pragmas.
if strings.HasPrefix(line, dbmatePragma) {
switch strings.TrimSpace(strings.TrimPrefix(line, dbmatePragma)) {
case "up":
state = up
case "down":
break Scan
}
}
// Write the line of the statement.
if !reDBMatePragma.MatchString(line) && state == up {
lines = append(lines, line)
}
}
return migrate.Stmts(strings.Join(lines, "\n"))
}
// Stmts understands the migration format used by amacneil/dbmate sql migration files.
func (f *DBMateFile) Stmts() ([]string, error) {
s, err := f.StmtDecls()
if err != nil {
return nil, err
}
stmts := make([]string, len(s))
for i := range s {
stmts[i] = s[i].Text
}
return stmts, nil
}
type (
// FlywayDir wraps migrate.LocalDir and provides a migrate.Scanner implementation able to understand files
// generated by the FlywayFormatter for migration directory replaying.
FlywayDir struct{ *migrate.LocalDir }
// FlywayFile wraps migrate.LocalFile with custom statements function.
FlywayFile struct{ *migrate.LocalFile }
)
// NewFlywayDir returns a new FlywayDir.
func NewFlywayDir(path string) (*FlywayDir, error) {
dir, err := migrate.NewLocalDir(path)
if err != nil {
return nil, err
}
return &FlywayDir{dir}, nil
}
// Files implements Scanner.Files. It looks for all files with .sql suffix. The given directory is recursively scanned
// for non-hidden subdirectories. All found files will be ordered by migration type (Baseline, Versioned, Repeatable)
// and filename.
func (d *FlywayDir) Files() ([]migrate.File, error) {
var ff flywayFiles
if err := fs.WalkDir(d, "", func(path string, e fs.DirEntry, err error) error {
if err != nil {
return err
}
if path != "" && e.IsDir() {
h, err := hidden(filepath.Join(d.Path(), path))
if err != nil {
return err
}
if h {
return fs.SkipDir
}
return nil
}
var (
pfx = e.Name()[0]
base = filepath.Base(e.Name())
ext = filepath.Ext(e.Name())
)
if ext != ".sql" || len(base) < 4 || (pfx != 'V' && pfx != 'B' && pfx != 'R') {
return nil
}
return ff.add(path)
}); err != nil {
return nil, err
}
var (
names = ff.names()
ret = make([]migrate.File, len(names))
)
for i, n := range names {
b, err := fs.ReadFile(d, n)
if err != nil {
return nil, fmt.Errorf("sql/migrate: read file %q: %w", n, err)
}
ret[i] = &FlywayFile{migrate.NewLocalFile(n, b)}
}
return ret, nil
}
// Desc implements File.Desc.
func (f FlywayFile) Desc() string {
return flywayDesc(f.Name())
}
// Version implements File.Version.
func (f FlywayFile) Version() string {
return flywayVersion(f.Name())
}
// SetRepeatableVersion iterates over the migration files and assigns repeatable migrations a version number since
// Atlas does not have the concept of repeatable migrations. Each repeatable migration file gets assigned the version
// of the preceding migration file (or 0) followed by an 'R'.
func SetRepeatableVersion(ff []migrate.File) {
// First find the index of the first repeatable migration file (if any).
var (
v string // last versioned migration version
idx = func() int {
for i, f := range ff {
if f.Version() == "" {
return i
}
}
return -1
}()
)
switch idx {
case -1:
// No repeatable migration does exist.
return
case 0:
// There is no preceding migration. Use Version "0".
v = "0"
default:
v = ff[idx-1].Version()
}
if v != "" {
// Every migration file following the first repeatable found are repeatable as well.
for i, f := range ff[idx:] {
ff[idx+i] = &FlywayFile{migrate.NewLocalFile(
fmt.Sprintf("V%sR__%s", v, f.Desc()),
f.Bytes(),
)}
}
}
}
// LiquibaseDir wraps migrate.LocalDir and provides a migrate.Scanner implementation able to understand files
// generated by the LiquibaseFormatter for migration directory replaying.
type LiquibaseDir struct{ *migrate.LocalDir }
// NewLiquibaseDir returns a new LiquibaseDir.
func NewLiquibaseDir(path string) (*LiquibaseDir, error) {
d, err := migrate.NewLocalDir(path)
if err != nil {
return nil, err
}
return &LiquibaseDir{d}, nil
}
const (
none int = iota
up
begin
end
goosePragma = "-- +goose"
dbmatePragma = "-- migrate:"
)
var (
reGoosePragma = regexp.MustCompile(regexp.QuoteMeta(goosePragma) + " Up|Down|StatementBegin|StatementEnd")
reDBMatePragma = regexp.MustCompile(dbmatePragma + "up|down")
)
// flywayFiles retrieves flyway migration files by calls to add(). It will only keep the latest baseline and ignore
// all versioned files that are included in that baseline.
type flywayFiles struct {
baseline string
versioned []string
repeatable []string
}
// add the given path to the migration files according to its type. The input directory is assumed to be valid
// according to the Flyway documentation (no duplicate versions, etc.).
func (ff *flywayFiles) add(path string) error {
switch p := filepath.Base(path)[0]; p {
case 'B':
if ff.baseline != "" && flywayVersion(path) < flywayVersion(ff.baseline) {
return nil
}
ff.baseline = path
// In case we set a new baseline, remove all versioned files with a version smaller than the new baseline.
var (
bv = flywayVersion(ff.baseline)
vs []string
)
for _, v := range ff.versioned {
if v > bv {
vs = append(vs, v)
}
}
ff.versioned = vs
return nil
case 'V':
v := flywayVersion(path)
if ff.baseline == "" || flywayVersion(ff.baseline) < v {
ff.versioned = append(ff.versioned, path)
}
return nil
case 'R':
ff.repeatable = append(ff.repeatable, path)
return nil
default:
return fmt.Errorf("sql/sqltool: unexpected Flyway prefix %q", p)
}
}
func (ff *flywayFiles) names() []string {
var names []string
if ff.baseline != "" {
names = append(names, ff.baseline)
}
sort.Strings(ff.versioned)
sort.Strings(ff.repeatable)
names = append(names, ff.versioned...)
names = append(names, ff.repeatable...)
return names
}
func flywayDesc(path string) string {
parts := strings.SplitN(path, "__", 2)
if len(parts) == 1 {
return ""
}
return strings.TrimSuffix(parts[1], ".sql")
}
func flywayVersion(path string) string {
// Repeatable migrations don't have a version.
if filepath.Base(path)[0] == 'R' {
return ""
}
return strings.SplitN(strings.TrimSuffix(filepath.Base(path), ".sql"), "__", 2)[0][1:]
}
func unexpectedPragmaErr(f migrate.File, line int, pragma string) error {
var tool string
switch f := f.(type) {
case *GooseFile:
tool = "goose"
case *DBMateFile:
tool = "dbmate"
default:
return fmt.Errorf("sql/migrate: unexpected migration file type '%T'", f)
}
return fmt.Errorf(
"sql/migrate: %s: %s:%d unexpected goosePragma '%s'",
tool, f.Name(), line, pragma,
)
}
// funcs contains the template.FuncMap for the different formatters.
var funcs = template.FuncMap{
"inc": func(x int) int { return x + 1 },
// now formats the current time in a lexicographically ascending order while maintaining human readability.
"now": func() string { return time.Now().UTC().Format("20060102150405") },
"rev": reverse,
}
// templateFormatter parses the given templates and passes them on to the migrate.NewTemplateFormatter.
func templateFormatter(templates ...string) migrate.Formatter {
tpls := make([]*template.Template, len(templates))
for i, t := range templates {
tpls[i] = template.Must(template.New("").Funcs(funcs).Parse(t))
}
tf, err := migrate.NewTemplateFormatter(tpls...)
if err != nil {
panic(err)
}
return tf
}
// reverse changes for the down migration.
func reverse(changes []*migrate.Change) []*migrate.Change {
n := len(changes)
rev := make([]*migrate.Change, n)
if n%2 == 1 {
rev[n/2] = changes[n/2]
}
for i, j := 0, n-1; i < j; i, j = i+1, j-1 {
rev[i], rev[j] = changes[j], changes[i]
}
return rev
}
atlas-0.7.2/sql/sqltool/tool_test.go 0000664 0000000 0000000 00000022324 14314555116 0017473 0 ustar 00root root 0000000 0000000 // Copyright 2021-present The Atlas Authors. All rights reserved.
// This source code is licensed under the Apache 2.0 license found
// in the LICENSE file in the root directory of this source tree.
package sqltool_test
import (
"fmt"
"io/fs"
"testing"
"time"
"ariga.io/atlas/sql/migrate"
"ariga.io/atlas/sql/sqltool"
"github.com/stretchr/testify/require"
)
var plan = &migrate.Plan{
Name: "tooling-plan",
Reversible: true,
Changes: []*migrate.Change{
{Cmd: "CREATE TABLE t1(c int)", Reverse: "DROP TABLE t1 IF EXISTS", Comment: "create table t1"},
{Cmd: "CREATE TABLE t2(c int)", Reverse: "DROP TABLE t2", Comment: "create table t2"},
},
}
func TestFormatters(t *testing.T) {
v := time.Now().UTC().Format("20060102150405")
for _, tt := range []struct {
name string
fmt migrate.Formatter
expected map[string]string
}{
{
"golang-migrate/migrate",
sqltool.GolangMigrateFormatter,
map[string]string{
v + "_tooling-plan.up.sql": `-- create table t1
CREATE TABLE t1(c int);
-- create table t2
CREATE TABLE t2(c int);
`,
v + "_tooling-plan.down.sql": `-- reverse: create table t2
DROP TABLE t2;
-- reverse: create table t1
DROP TABLE t1 IF EXISTS;
`,
},
},
{
"pressly/goose",
sqltool.GooseFormatter,
map[string]string{
v + "_tooling-plan.sql": `-- +goose Up
-- create table t1
CREATE TABLE t1(c int);
-- create table t2
CREATE TABLE t2(c int);
-- +goose Down
-- reverse: create table t2
DROP TABLE t2;
-- reverse: create table t1
DROP TABLE t1 IF EXISTS;
`,
},
},
{
"flyway",
sqltool.FlywayFormatter,
map[string]string{
"V" + v + "__tooling-plan.sql": `-- create table t1
CREATE TABLE t1(c int);
-- create table t2
CREATE TABLE t2(c int);
`,
"U" + v + "__tooling-plan.sql": `-- reverse: create table t2
DROP TABLE t2;
-- reverse: create table t1
DROP TABLE t1 IF EXISTS;
`,
},
},
{
"liquibase",
sqltool.LiquibaseFormatter,
map[string]string{
v + "_tooling-plan.sql": fmt.Sprintf(`--liquibase formatted sql
--changeset atlas:%s-1
--comment: create table t1
CREATE TABLE t1(c int);
--rollback: DROP TABLE t1 IF EXISTS;
--changeset atlas:%s-2
--comment: create table t2
CREATE TABLE t2(c int);
--rollback: DROP TABLE t2;
`, v, v),
},
},
{
"amacneil/dbmate",
sqltool.DBMateFormatter,
map[string]string{
v + "_tooling-plan.sql": `-- migrate:up
-- create table t1
CREATE TABLE t1(c int);
-- create table t2
CREATE TABLE t2(c int);
-- migrate:down
-- reverse: create table t2
DROP TABLE t2;
-- reverse: create table t1
DROP TABLE t1 IF EXISTS;
`,
},
},
} {
t.Run(tt.name, func(t *testing.T) {
d := dir(t)
pl := migrate.NewPlanner(nil, d, migrate.PlanFormat(tt.fmt), migrate.PlanWithChecksum(false))
require.NotNil(t, pl)
require.NoError(t, pl.WritePlan(plan))
require.Equal(t, len(tt.expected), countFiles(t, d))
for name, content := range tt.expected {
requireFileEqual(t, d, name, content)
}
})
}
}
func TestScanners(t *testing.T) {
for _, tt := range []struct {
name string
dir migrate.Dir
versions, descriptions []string
stmts [][]string
}{
{
name: "golang-migrate",
dir: func() migrate.Dir {
d, err := sqltool.NewGolangMigrateDir("testdata/golang-migrate")
require.NoError(t, err)
return d
}(),
versions: []string{"1", "2"},
descriptions: []string{"initial", "second_migration"},
stmts: [][]string{
{"CREATE TABLE tbl\n(\n col INT\n);"},
{"CREATE TABLE tbl_2 (col INT);"},
},
},
{
name: "goose",
dir: func() migrate.Dir {
d, err := sqltool.NewGooseDir("testdata/goose")
require.NoError(t, err)
return d
}(),
versions: []string{"1", "2"},
descriptions: []string{"initial", "second_migration"},
stmts: [][]string{
{
"CREATE TABLE post\n(\n id int NOT NULL,\n title text,\n body text,\n PRIMARY KEY (id)\n);",
"ALTER TABLE post ADD created_at TIMESTAMP NOT NULL;",
"INSERT INTO post (title) VALUES (\n'This is\nmy multiline\n\nvalue');",
},
{
"ALTER TABLE post ADD updated_at TIMESTAMP NOT NULL;",
"CREATE\nOR REPLACE FUNCTION histories_partition_creation( DATE, DATE )\nreturns void AS $$\nDECLARE\ncreate_query text;\nBEGIN\nFOR create_query IN\nSELECT 'CREATE TABLE IF NOT EXISTS histories_'\n || TO_CHAR(d, 'YYYY_MM')\n || ' ( CHECK( created_at >= timestamp '''\n || TO_CHAR(d, 'YYYY-MM-DD 00:00:00')\n || ''' AND created_at < timestamp '''\n || TO_CHAR(d + INTERVAL '1 month', 'YYYY-MM-DD 00:00:00')\n || ''' ) ) inherits ( histories );'\nFROM generate_series($1, $2, '1 month') AS d LOOP\n EXECUTE create_query;\nEND LOOP; -- LOOP END\nEND; -- FUNCTION END\n$$\nlanguage plpgsql;",
},
},
},
{
name: "flyway",
dir: func() migrate.Dir {
d, err := sqltool.NewFlywayDir("testdata/flyway")
require.NoError(t, err)
return d
}(),
versions: []string{"2", "3", ""},
descriptions: []string{"baseline", "third_migration", "views"},
stmts: [][]string{
{
"CREATE TABLE post\n(\n id int NOT NULL,\n title text,\n body text,\n created_at TIMESTAMP NOT NULL\n PRIMARY KEY (id)\n);",
"INSERT INTO post (title, created_at) VALUES (\n'This is\nmy multiline\n\nvalue', NOW());",
},
{"ALTER TABLE tbl_2 ADD col_1 INTEGER NOT NULL;"},
{"CREATE VIEW `my_view` AS SELECT * FROM `post`;"},
},
},
{
name: "liquibase",
dir: func() migrate.Dir {
d, err := sqltool.NewLiquibaseDir("testdata/liquibase")
require.NoError(t, err)
return d
}(),
versions: []string{"1", "2"},
descriptions: []string{"initial", "second_migration"},
stmts: [][]string{
{
"CREATE TABLE post\n(\n id int NOT NULL,\n title text,\n body text,\n PRIMARY KEY (id)\n);",
"ALTER TABLE post ADD created_at TIMESTAMP NOT NULL;",
"INSERT INTO post (title) VALUES (\n'This is\nmy multiline\n\nvalue');",
},
{"CREATE TABLE tbl_2 (col INT);"},
},
},
{
name: "dbmate",
dir: func() migrate.Dir {
d, err := sqltool.NewDBMateDir("testdata/dbmate")
require.NoError(t, err)
return d
}(),
versions: []string{"1", "2"},
descriptions: []string{"initial", "second_migration"},
stmts: [][]string{
{
"CREATE TABLE post\n(\n id int NOT NULL,\n title text,\n body text,\n PRIMARY KEY (id)\n);",
"ALTER TABLE post ADD created_at TIMESTAMP NOT NULL;",
"INSERT INTO post (title) VALUES (\n'This is\nmy multiline\n\nvalue');",
},
{"CREATE TABLE tbl_2 (col INT);"},
},
},
} {
t.Run(tt.name, func(t *testing.T) {
files, err := tt.dir.Files()
require.NoError(t, err)
require.Len(t, files, len(tt.versions))
for i := range tt.versions {
require.Equal(t, tt.versions[i], files[i].Version())
require.Equal(t, tt.descriptions[i], files[i].Desc())
stmts, err := files[i].Stmts()
require.NoError(t, err)
require.Len(t, stmts, len(tt.stmts[i]))
for j, stmt := range stmts {
require.Equal(t, tt.stmts[i][j], stmt)
}
}
})
}
}
func TestChecksum(t *testing.T) {
for _, tt := range []struct {
name string
dir migrate.Dir
files []string // files expected to be part of the checksum (in order)
}{
{
name: "golang-migrate",
dir: func() migrate.Dir {
d, err := sqltool.NewGolangMigrateDir("testdata/golang-migrate")
require.NoError(t, err)
return d
}(),
files: []string{
"1_initial.down.sql",
"1_initial.up.sql",
"2_second_migration.down.sql",
"2_second_migration.up.sql",
},
},
{
name: "goose",
dir: func() migrate.Dir {
d, err := sqltool.NewGooseDir("testdata/goose")
require.NoError(t, err)
return d
}(),
files: []string{
"1_initial.sql",
"2_second_migration.sql",
},
},
{
name: "flyway",
dir: func() migrate.Dir {
d, err := sqltool.NewFlywayDir("testdata/flyway")
require.NoError(t, err)
return d
}(),
files: []string{
"B2__baseline.sql",
"R__views.sql",
"U1__initial.sql",
"V1__initial.sql",
"V2__second_migration.sql",
"V3__third_migration.sql",
},
},
{
name: "liquibase",
dir: func() migrate.Dir {
d, err := sqltool.NewLiquibaseDir("testdata/liquibase")
require.NoError(t, err)
return d
}(),
files: []string{
"1_initial.sql",
"2_second_migration.sql",
},
},
{
name: "dbmate",
dir: func() migrate.Dir {
d, err := sqltool.NewDBMateDir("testdata/dbmate")
require.NoError(t, err)
return d
}(),
files: []string{
"1_initial.sql",
"2_second_migration.sql",
},
},
} {
t.Run(tt.name, func(t *testing.T) {
sum, err := tt.dir.Checksum()
require.NoError(t, err)
require.Len(t, sum, len(tt.files))
for i := range tt.files {
require.Equal(t, tt.files[i], sum[i].N)
}
})
}
}
func dir(t *testing.T) migrate.Dir {
p := t.TempDir()
d, err := migrate.NewLocalDir(p)
require.NoError(t, err)
return d
}
func countFiles(t *testing.T, d migrate.Dir) int {
files, err := fs.ReadDir(d, "")
require.NoError(t, err)
return len(files)
}
func requireFileEqual(t *testing.T, d migrate.Dir, name, contents string) {
c, err := fs.ReadFile(d, name)
require.NoError(t, err)
require.Equal(t, contents, string(c))
}
Atlas is an open-source project maintained by [Ariga Technologies Ltd](https://ariga.io),
a tech company founded by the maintainers of [Ent](https://entgo.io).
### Reaching Out
If you have a question or want to chat with the Atlas community,
join our [Discord Server](https://discord.com/invite/QhsmBAWzrC) or
[open an issue](https://github.com/ariga/atlas/issues) on our [GitHub Repo](https://github.com/ariga/atlas). atlas-0.7.2/doc/md/atlas-schema/ 0000775 0000000 0000000 00000000000 14314555116 0016340 5 ustar 00root root 0000000 0000000 atlas-0.7.2/doc/md/atlas-schema/input.md 0000664 0000000 0000000 00000004705 14314555116 0020027 0 ustar 00root root 0000000 0000000 ---
id: input-variables
slug: /atlas-schema/input-variables
title: Input Variables
---
In some cases, it is desirable to reuse an Atlas HCL document in different contexts.
For example, many organizations manage a multi-tenant architecture where the same database
schema is replicated per tenant. For this reason, the Atlas DDL supports input variables.
Input variables are defined using the `variable` block:
```hcl
variable "comment" {
type = string // | int | bool
default = "rotemtam"
}
```
Once defined, their value can be referenced using `var.
