This is an automated email from the ASF dual-hosted git repository.
zabetak pushed a commit to branch site
in repository https://gitbox.apache.org/repos/asf/calcite.git
commit 72d16e5ff419ec9e86f96774c8c4d85af448891b
Author: Stamatis Zampetakis <zabe...@gmail.com>
AuthorDate: Thu Feb 6 09:37:55 2020 +0100
[CALCITE-2905] Update documentation for Gradle
This is part of the commit 66c9cd5e1c88ebe834e6f0f299cfb1e1dffa4296 applied
on master. Cannot cherry-pick the entire commit since it contains many
important changes which affect many things apart from the site.
---
README.md | 1 +
geode/README.md | 1 -
site/README.md | 6 +-
site/_docs/adapter.md | 1 -
site/_docs/algebra.md | 1 -
site/_docs/elasticsearch_adapter.md | 1 -
site/_docs/howto.md | 290 ++++++++++++-------------------
site/_docs/index.md | 2 -
site/_docs/lattice.md | 1 -
site/_docs/tutorial.md | 26 ++-
site/_posts/2019-03-26-release-1.19.0.md | 1 -
site/develop/index.md | 13 +-
12 files changed, 136 insertions(+), 208 deletions(-)
diff --git a/README.md b/README.md
index 7a0f971..073160a 100644
--- a/README.md
+++ b/README.md
@@ -17,6 +17,7 @@ limitations under the License.
{% endcomment %}
-->
[](https://travis-ci.org/apache/calcite)
+[](https://github.com/apache/calcite/actions)
[](https://ci.appveyor.com/project/ApacheSoftwareFoundation/calcite)
# Apache Calcite
diff --git a/geode/README.md b/geode/README.md
index 7099e23..5c6a69d 100644
--- a/geode/README.md
+++ b/geode/README.md
@@ -18,4 +18,3 @@ limitations under the License.
-->
##Apache Geode SQL/JBC Adapter
-
diff --git a/site/README.md b/site/README.md
index c528f9a..13c1ed5 100644
--- a/site/README.md
+++ b/site/README.md
@@ -41,10 +41,12 @@ Site generation currently works best with ruby-2.5.1.
### Add javadoc
1. `cd ..`
-2. `mvn -DskipTests site`
+2. `./gradlew javadocAggregate`
3. `rm -rf site/target/apidocs site/target/testapidocs`
`rmdir site\target\apidocs site\target\testapidocs /S /Q` (Windows)
-4. `mv target/site/apidocs target/site/testapidocs site/target`
+4. `mkdir site/target`
+ `mkdir site\target` (Windows)
+4. `mv build/docs/javadocAggregate site/target/apidocs`
`for /d %a in (target\site\apidocs* target\site\testapidocs*) do move %a
site\target` (Windows)
### Running locally
diff --git a/site/_docs/adapter.md b/site/_docs/adapter.md
index feb357b..3e75b38 100644
--- a/site/_docs/adapter.md
+++ b/site/_docs/adapter.md
@@ -614,4 +614,3 @@ While preparing a query Calcite combines all of the
applicable metadata
providers and maintains a cache so that a given piece of metadata (for example
the selectivity of the condition `x > 10` in a particular `Filter` operator)
is computed only once.
-
diff --git a/site/_docs/algebra.md b/site/_docs/algebra.md
index 70301a1..d589fb0 100644
--- a/site/_docs/algebra.md
+++ b/site/_docs/algebra.md
@@ -472,4 +472,3 @@ To further modify the `AggCall`, call its methods:
| `distinct(distinct)` | Eliminates duplicate values before aggregating if
`distinct`
| `filter(expr)` | Filters rows before aggregating (see SQL `FILTER
(WHERE ...)`)
| `sort(expr...)`<br/>`sort(exprList)` | Sorts rows before aggregating (see
SQL `WITHIN GROUP`)
-
diff --git a/site/_docs/elasticsearch_adapter.md
b/site/_docs/elasticsearch_adapter.md
index 1c3a634..11bc94b 100644
--- a/site/_docs/elasticsearch_adapter.md
+++ b/site/_docs/elasticsearch_adapter.md
@@ -155,4 +155,3 @@ scroll is automatically cleared (removed) when all query
resuts are consumed.
Currently this adapter supports ElasticSearch versions 6.x (or newer).
Generally
we try to follow official [support
schedule](https://www.elastic.co/support/eol).
Also, types are not supported (this adapter only supports indices).
-
diff --git a/site/_docs/howto.md b/site/_docs/howto.md
index 6b7a550..23274dc 100644
--- a/site/_docs/howto.md
+++ b/site/_docs/howto.md
@@ -31,7 +31,7 @@ adapters.
## Building from a source distribution
-Prerequisite is Java (JDK 8, 9, 10, 11, or 12) on your path.
+Prerequisite is Java (JDK 8, 9, 10, 11, 12, or 13) on your path.
Unpack the source distribution `.tar.gz` file,
`cd` to the root directory of the unpacked source,
@@ -40,16 +40,16 @@ then build using the included maven wrapper:
{% highlight bash %}
$ tar xvfz calcite-1.21.0-source.tar.gz
$ cd calcite-1.21.0
-$ ./mvnw install
+$ ./gradlew build
{% endhighlight %}
[Running tests](#running-tests) describes how to run more or fewer
tests.
-## Building from git
+## Building from Git
Prerequisites are git
-and Java (JDK 8, 9, 10, 11, or 12) on your path.
+and Java (JDK 8, 9, 10, 11, 12, or 13) on your path.
Create a local copy of the github repository,
`cd` to its root directory,
@@ -58,44 +58,46 @@ then build using the included maven wrapper:
{% highlight bash %}
$ git clone git://github.com/apache/calcite.git
$ cd calcite
-$ ./mvnw install
+$ ./gradlew build
{% endhighlight %}
Calcite includes a number of machine-generated codes. By default, these are
regenerated on every build, but this has the negative side-effect of causing
a re-compilation of the entire project when the non-machine-generated code
-has not changed. To make sure incremental compilation still works as intended,
-provide the `skipGenerate` command line option with your maven command.
-If you invoke the `clean` lifecycle phase, you must not specify the
-`skipGenerate` option as it will not recompile the necessary code for the build
-to succeed.
+has not changed.
-{% highlight bash %}
-$ mvn clean
-$ mvn package
-... hacks ...
-$ mvn package -DskipGenerate
-{% endhighlight %}
+Typically re-generation is called automatically when the relevant templates
+are changed, and it should work transparently.
+However if your IDE does not generate sources (e.g.
`core/build/javacc/javaCCMain/org/apache/calcite/sql/parser/impl/SqlParserImpl.java`),
+then you can call `./gradlew generateSources` tasks manually.
[Running tests](#running-tests) describes how to run more or fewer
tests.
-## If you already have Apache Maven
+## Gradle vs Gradle wrapper
-If you have already installed Maven and it is on your path, then you
-can use `mvn` rather than `./mvnw` in commands. You need Maven version
-3.5.2 or later.
+Calcite uses Gradle wrapper to make a consistent build environment.
+In the typical case you don't need to install Gradle manually, and
+`./gradlew` would download the proper version for you and verify the expected
checksum.
+
+You can install Gradle manually, however please note that there might
+be impedance mismatch between different versions.
## Running tests
The test suite will run by default when you build, unless you specify
-`-DskipTests`:
+`-x test`
{% highlight bash %}
-$ ./mvnw -DskipTests clean install
-$ ./mvnw test
+$ ./gradlew assemble # build the artifacts
+$ ./gradlew build -x test # build the artifacts, verify code style, skip tests
+$ ./gradlew check # verify code style, execute tests
+$ ./gradlew test # execute tests
+$ ./gradlew checkstyleMain checkstyleTest # verify code style
{% endhighlight %}
+You can use `./gradlew assemble` to build the artifacts and skip all tests and
verifications.
+
There are other options that control which tests are run, and in what
environment, as follows.
@@ -115,6 +117,18 @@ environment, as follows.
* `-Dcalcite.test.splunk` enables tests that run against Splunk.
Splunk must be installed and running.
+Note: tests are executed in a forked JVM, so system properties are not passed
automatically
+when running tests with Gradle.
+By default, the build script passes the following `-D...` properties
+(see `passProperty` in `build.gradle.kts`):
+
+* `java.awt.headless`
+* `junit.jupiter.execution.parallel.enabled`, default: `true`
+* `junit.jupiter.execution.timeout.default`, default: `5 m`
+* `user.language`, default: `TR`
+* `user.country`, default: `tr`
+* `calcite.**` (to enable `calcite.test.db` and others above)
+
## Running integration tests
For testing Calcite's external adapters, a test virtual machine should be used.
@@ -158,15 +172,16 @@ Note: test VM should be started before you launch
integration tests. Calcite its
Command line:
-* Executing regular unit tests (does not require external data): no change.
`mvn test` or `mvn install`.
-* Executing all tests, for all the DBs: `mvn verify -Pit`. `it` stands for
"integration-test". `mvn install -Pit` works as well.
-* Executing just tests for external DBs, excluding unit tests: `mvn -Dtest=foo
-DfailIfNoTests=false -Pit verify`
-* Executing just MongoDB tests: `cd mongo; mvn verify -Pit`
+* Executing regular unit tests (does not require external data): no change.
`./gradlew test` or `./gradlew build`.
+* Executing all tests, for all the DBs: `./gradlew test integTestAll`.
+* Executing just tests for external DBs, excluding unit tests: `./gradlew
integTestAll`
+* Executing PostgreSQL JDBC tests: `./gradlew integTestPostgresql`
+* Executing just MongoDB tests: `./gradlew :mongo:build`
From within IDE:
* Executing regular unit tests: no change.
-* Executing MongoDB tests: run `MongoAdapterIT.java` as usual (no additional
properties are required)
+* Executing MongoDB tests: run `MongoAdapterTest.java` with
`calcite.integrationTest=true` system property
* Executing MySQL tests: run `JdbcTest` and `JdbcAdapterTest` with setting
`-Dcalcite.test.db=mysql`
* Executing PostgreSQL tests: run `JdbcTest` and `JdbcAdapterTest` with
setting `-Dcalcite.test.db=postgresql`
@@ -193,10 +208,10 @@ To setup [IntelliJ
IDEA](https://www.jetbrains.com/idea/), follow the standard s
Start with [building Calcite from the command
line](#building-from-a-source-distribution).
-Go to *File > Open...* and open up Calcite's `pom.xml` file.
+Go to *File > Open...* and open up Calcite's root `build.gradle.kts` file.
When IntelliJ asks if you want to open it as a project or a file, select
project.
Also, say yes when it asks if you want a new window.
-IntelliJ's Maven project importer should handle the rest.
+IntelliJ's Gradle project importer should handle the rest.
There is a partially implemented IntelliJ code style configuration that you
can import located [on
GitHub](https://gist.github.com/gianm/27a4e3cad99d7b9b6513b6885d3cfcc9).
It does not do everything needed to make Calcite's style checker happy, but
@@ -208,18 +223,9 @@ Once the importer is finished, test the project setup.
For example, navigate to the method `JdbcTest.testWinAgg` with
*Navigate > Symbol* and enter `testWinAgg`. Run `testWinAgg` by right-clicking
and selecting *Run* (or the equivalent keyboard shortcut).
-If you encounter an error while running the `JdbcTest.testWinAgg` , run the
following Maven command from the command line:
-
-`$ ./mvnw -DskipTests clean install`
-
-You should see `"BUILD SUCCESS"`.
-
-Once that is complete, proceed with running `JdbcTest.testWinAgg`.
-
### Setting up NetBeans
-From the main menu, select *File > Open Project* and navigate to a name of the
project (Calcite) with a small Maven icon, and choose to open.
-(See [this
tutorial](https://www.packtpub.com/mapt/book/application_development/9781785286124/2/ch02lvl1sec23/importing-an-existing-maven-project-in-netbeans)
for an example of how to open a Maven project)
+From the main menu, select *File > Open Project* and navigate to a name of the
project (Calcite) with a small Gradle icon, and choose to open.
Wait for NetBeans to finish importing all dependencies.
To ensure that the project is configured successfully, navigate to the method
`testWinAgg` in `org.apache.calcite.test.JdbcTest`.
@@ -227,6 +233,10 @@ Right-click on the method and select to *Run Focused Test
Method*.
NetBeans will run a Maven process, and you should see in the command output
window a line with
`Running org.apache.calcite.test.JdbcTest` followed by `"BUILD SUCCESS"`.
+Note: it is not clear if NetBeans automatically generates relevant sources on
project import,
+so you might need to run `./gradlew generateSources` before importing the
project (and when you
+update template parser sources, and project version)
+
## Tracing
To enable tracing, add the following flags to the java command line:
@@ -312,8 +322,8 @@ Calcite model:
{% highlight bash %}
$ ./sqlline
-sqlline> !connect
jdbc:calcite:model=mongodb/target/test-classes/mongo-model.json admin admin
-Connecting to jdbc:calcite:model=mongodb/target/test-classes/mongo-model.json
+sqlline> !connect
jdbc:calcite:model=mongodb/src/test/resources/mongo-model.json admin admin
+Connecting to jdbc:calcite:model=mongodb/src/test/resources/mongo-model.json
Connected to: Calcite (version 1.x.x)
Driver: Calcite JDBC Driver (version 1.x.x)
Autocommit status: true
@@ -499,32 +509,47 @@ file by following instructions in the `KEYS` file.
ball because that would be
[redundant](https://issues.apache.org/jira/browse/CALCITE-1746).)
-## Set up Maven repository credentials (for Calcite committers)
+## Set up Nexus repository credentials (for Calcite committers)
+
+Gradle provides multiple ways to [configure project
properties](https://docs.gradle.org/current/userguide/build_environment.html#sec:gradle_configuration_properties).
+For instance, you could update `$HOME/.gradle/gradle.properties`.
+
+Note: the build script would print the missing properties, so you can try
running it and let it complain on the missing ones.
-Follow the instructions
[here](https://www.apache.org/dev/publishing-maven-artifacts.html#dev-env) to
add your credentials to your maven configuration.
+The following options are used:
+
+{% highlight properties %}
+asfCommitterId=
+asfNexusUsername=
+asfNexusPassword=
+asfSvnUsername=
+asfSvnPassword=
+{% endhighlight %}
+
+Note: when https://github.com/vlsi/asflike-release-environment is used, the
credentials are takend from
+`asfTest...` (e.g. `asfTestNexusUsername=test`)
+
+Note: if you want to uses `gpg-agent`, you need to pass `useGpgCmd` property,
and specify the key id
+via `signing.gnupg.keyName`.
## Making a snapshot (for Calcite committers)
Before you start:
-* Set up signing keys as described above.
* Make sure you are using JDK 8.
* Make sure build and tests succeed with `-Dcalcite.test.db=hsqldb` (the
default)
{% highlight bash %}
-# Tell GPG how to read a password from your terminal
-export GPG_TTY=$(tty)
-
# Make sure that there are no junk files in the sandbox
git clean -xn
-./mvnw clean
-
-./mvnw -Papache-release install
+# Publish snapshot artifacts
+./gradlew clean publish -Pasf
{% endhighlight %}
-When the dry-run has succeeded, change `install` to `deploy`.
+## Making a release candidate (for Calcite committers)
-## Making a release (for Calcite committers)
+Note: release artifacts (dist.apache.org and repository.apache.org) are
managed with
+[stage-vote-release-plugin](https://github.com/vlsi/vlsi-release-plugins/tree/master/plugins/stage-vote-release-plugin)
Before you start:
@@ -532,20 +557,18 @@ Before you start:
* Make sure you are using JDK 8 (not 9 or 10).
* Check that `README` and `site/_docs/howto.md` have the correct version
number.
* Check that `NOTICE` has the current copyright year.
-* Set `version.major` and `version.minor` in `pom.xml`.
-* Make sure build and tests succeed, including with `-P it,it-oracle`.
-* Make sure that `./mvnw javadoc:javadoc javadoc:test-javadoc` succeeds
+* Check that `calcite.version` has the proper value in `/gradle.properties`.
+* Make sure build and tests succeed
+* Make sure that `./gradlew javadoc` succeeds
(i.e. gives no errors; warnings are OK)
* Generate a report of vulnerabilities that occur among dependencies,
- using `-Ppedantic`; if you like, run again with `-DfailBuildOnCVSS=8` to see
- whether serious vulnerabilities exist. Report to
[priv...@calcite.apache.org](mailto:priv...@calcite.apache.org)
+ using `./gradlew dependencyCheckUpdate dependencyCheckAggregate`.
+ Report to [priv...@calcite.apache.org](mailto:priv...@calcite.apache.org)
if new critical vulnerabilities are found among dependencies.
-* Make sure that `./mvnw apache-rat:check` succeeds. (It will be run as part of
- the release, but it's better to trouble-shoot early.)
* Decide the supported configurations of JDK, operating system and
Guava. These will probably be the same as those described in the
release notes of the previous release. Document them in the release
- notes. To test Guava version _x.y_, specify `-Dguava.version=x.y`
+ notes. To test Guava version _x.y_, specify `-Pguava.version=x.y`
* Optional extra tests:
* `-Dcalcite.test.db=mysql`
* `-Dcalcite.test.db=hsqldb`
@@ -580,27 +603,19 @@ SELECT NVL(ST_Is3D(ST_PointFromText('POINT(-71.064544
42.28787)')), TRUE);
> !quit
{% endhighlight %}
-Create a release branch named after the release, e.g. `branch-1.1`, and push
it to Apache.
+The release candidate process does not add commits,
+so there's no harm if it fails. It might leave `-rc` tag behind
+which can be removed if required.
-{% highlight bash %}
-$ git checkout -b branch-X.Y
-$ git push -u origin branch-X.Y
-{% endhighlight %}
+You can perform a dry-run release with a help of
https://github.com/vlsi/asflike-release-environment
+That would perform the same steps, however it would push changes to the mock
Nexus, Git, and SVN servers.
-We will use the branch for the entire the release process. Meanwhile,
-we do not allow commits to the master branch. After the release is
-final, we can use `git merge --ff-only` to append the changes on the
-release branch onto the master branch. (Apache does not allow reverts
-to the master branch, which makes it difficult to clean up the kind of
-messy commits that inevitably happen while you are trying to finalize
-a release.)
+If any of the steps fail, fix the problem, and
+start again from the top.
-Now, set up your environment and do a dry run. The dry run will not
-commit any changes back to git and gives you the opportunity to verify
-that the release process will complete as expected.
+### To prepare a release candidate directly in your environment:
-If any of the steps fail, clean up (see below), fix the problem, and
-start again from the top.
+Pick a release candidate index and ensure it does not interfere with previous
candidates for the version.
{% highlight bash %}
# Tell GPG how to read a password from your terminal
@@ -608,23 +623,17 @@ export GPG_TTY=$(tty)
# Make sure that there are no junk files in the sandbox
git clean -xn
-./mvnw clean
-# Do a dry run of the release:prepare step, which sets version numbers
-# (accept the default tag name of calcite-X.Y.Z).
-# Note X.Y.Z is the current version we're trying to release (e.g. 1.8.0),
-# and X.(Y+1).Z is the next development version (e.g. 1.9.0).
-./mvnw -DdryRun=true -DskipTests -DreleaseVersion=X.Y.Z
-DdevelopmentVersion=X.(Y+1).Z-SNAPSHOT -Papache-release
-Darguments=-DskipTests release:prepare 2>&1 | tee /tmp/prepare-dry.log
+# Dry run the release candidate (push to asf-like-environment)
+./gradlew prepareVote -Prc=1
-# If you have multiple GPG keys, you can select the key used to sign the
release by adding `-Dgpg.keyname=${GPG_KEY_ID}` to `-Darguments`:
-./mvnw -DdryRun=true -DskipTests -DreleaseVersion=X.Y.Z
-DdevelopmentVersion=X.(Y+1).Z-SNAPSHOT -Papache-release
-Darguments="-DskipTests -Dgpg.keyname=${GPG_KEY_ID}" release:prepare 2>&1 |
tee /tmp/prepare-dry.log
+# Push release candidate to ASF servers
+./gradlew prepareVote -Prc=1 -Pasf
{% endhighlight %}
-Check the artifacts.
-Note that when performing the dry run `SNAPSHOT` will appear in any file or
directory names given below.
-The version will be automatically changed when performing the release for real.
+#### Checking the artifacts
-* In the `target` directory should be these 3 files, among others:
+* In the `release/build/distributions` directory should be these 3 files,
among others:
* `apache-calcite-X.Y.Z-src.tar.gz`
* `apache-calcite-X.Y.Z-src.tar.gz.asc`
* `apache-calcite-X.Y.Z-src.tar.gz.sha256`
@@ -638,36 +647,12 @@ The version will be automatically changed when performing
the release for real.
* Check that the copyright year in `NOTICE` is correct
* Make sure that there is no `KEYS` file in the source distros
* In each .jar (for example
- `core/target/calcite-core-X.Y.Z.jar` and
- `mongodb/target/calcite-mongodb-X.Y.Z-sources.jar`), check
- that the `META-INF` directory contains `DEPENDENCIES`, `LICENSE`,
- `NOTICE` and `git.properties`
-* In `core/target/calcite-core-X.Y.Z.jar`,
- check that `org-apache-calcite-jdbc.properties` is
- present and does not contain un-substituted `${...}` variables
+ `core/build/libs/calcite-core-X.Y.Z.jar` and
+ `mongodb/build/libs/calcite-mongodb-X.Y.Z-sources.jar`), check
+ that the `META-INF` directory contains `LICENSE`,
+ `NOTICE`
* Check PGP, per [this](https://httpd.apache.org/dev/verification.html)
-Now, remove the `-DdryRun` flag and run the release for real.
-For this step you'll have to add the [Apache
servers](https://maven.apache.org/developers/committer-settings.html) to
`~/.m2/settings.xml`.
-
-{% highlight bash %}
-# Make sure that there are no junk files in the sandbox; performing a dry run
may have generated
-# redundant files that do not need to be present in the release artifacts.
-git clean -xn
-./mvnw clean
-
-# Prepare sets the version numbers, creates a tag, and pushes it to git
-# Note X.Y.Z is the current version we're trying to release, and X.Y+1.Z is
the next development version.
-# For example, if I am currently building a release for 1.16.0, X.Y.Z would be
1.16.0 and X.Y+1.Z would be 1.17.0.
-./mvnw -DdryRun=false -DskipTests -DreleaseVersion=X.Y.Z
-DdevelopmentVersion=X.Y+1.Z-SNAPSHOT -Papache-release -Darguments=-DskipTests
release:prepare 2>&1 | tee /tmp/prepare.log
-
-# If you have multiple GPG keys, you can select the key used to sign the
release by adding `-Dgpg.keyname=${GPG_KEY_ID}` to `-Darguments`:
-./mvnw -DdryRun=false -DskipTests -DreleaseVersion=X.Y.Z
-DdevelopmentVersion=X.Y+1.Z-SNAPSHOT -Papache-release -Darguments="-DskipTests
-Dgpg.keyname=${GPG_KEY_ID}" release:prepare 2>&1 | tee /tmp/prepare.log
-
-# Perform checks out the tagged version, builds, and deploys to the staging
repository
-./mvnw -DskipTests -Papache-release release:perform 2>&1 | tee /tmp/perform.log
-{% endhighlight %}
-
Verify the staged artifacts in the Nexus repository:
* Go to [https://repository.apache.org/](https://repository.apache.org/) and
login
@@ -679,45 +664,10 @@ Verify the staged artifacts in the Nexus repository:
https://repository.apache.org/content/repositories/orgapachecalcite-1000
(or a similar URL)
-Upload the artifacts via subversion to a staging area,
-https://dist.apache.org/repos/dist/dev/calcite/apache-calcite-X.Y.Z-rcN:
-
-{% highlight bash %}
-# Create a subversion workspace, if you haven't already
-mkdir -p ~/dist/dev
-pushd ~/dist/dev
-svn co https://dist.apache.org/repos/dist/dev/calcite
-popd
-
-# Move the files into a directory
-mkdir ~/dist/dev/calcite/apache-calcite-X.Y.Z-rcN
-mv apache-calcite-* ~/dist/dev/calcite/apache-calcite-X.Y.Z-rcN
-
-# Check in
-cd ~/dist/dev/calcite
-svn add apache-calcite-X.Y.Z-rcN
-svn ci
-{% endhighlight %}
-
## Cleaning up after a failed release attempt (for Calcite committers)
-{% highlight bash %}
-# Make sure that the tag you are about to generate does not already
-# exist (due to a failed release attempt)
-git tag
-
-# If the tag exists, delete it locally and remotely
-git tag -d calcite-X.Y.Z
-git push origin :refs/tags/calcite-X.Y.Z
-
-# Remove modified files
-./mvnw release:clean
-
-# Check whether there are modified files and if so, go back to the
-# original git commit
-git status
-git reset --hard HEAD
-{% endhighlight %}
+If something is not correct, you can fix it, commit it, and prepare the next
candidate.
+The release candidate tags might be kept for a while.
## Validate a release
@@ -754,6 +704,8 @@ checkHash apache-calcite-X.Y.Z-rcN
## Get approval for a release via Apache voting process (for Calcite
committers)
Release vote on dev list
+Note: the draft mail is printed as the final step of `prepareVote` task,
+and you can find the draft in `/build/prepareVote/mail.txt`
{% highlight text %}
To: d...@calcite.apache.org
@@ -848,31 +800,15 @@ This is based on the time when you expect to announce the
release.
This is usually a day after the vote closes.
Remember that UTC date changes at 4pm Pacific time.
-Promote the staged nexus artifacts.
-
-* Go to [https://repository.apache.org/](https://repository.apache.org/) and
login
-* Under "Build Promotion" click "Staging Repositories"
-* In the line with "orgapachecalcite-xxxx", check the box
-* Press "Release" button
-Check the artifacts into svn.
+### Publishing directly in your environment:
{% highlight bash %}
-# Get the release candidate.
-mkdir -p ~/dist/dev
-cd ~/dist/dev
-svn co https://dist.apache.org/repos/dist/dev/calcite
-
-# Copy the artifacts. Note that the copy does not have '-rcN' suffix.
-mkdir -p ~/dist/release
-cd ~/dist/release
-svn co https://dist.apache.org/repos/dist/release/calcite
-cd calcite
-cp -rp ../../dev/calcite/apache-calcite-X.Y.Z-rcN apache-calcite-X.Y.Z
-svn add apache-calcite-X.Y.Z
-
-# Check in.
-svn ci
+# Dry run publishing the release (push to asf-like-environment)
+./gradlew publishDist -Prc=1
+
+# Publish the release to ASF servers
+./gradlew publishDist -Prc=1 -Pasf
{% endhighlight %}
Svnpubsub will publish to the
diff --git a/site/_docs/index.md b/site/_docs/index.md
index cf4560c..fda9999 100644
--- a/site/_docs/index.md
+++ b/site/_docs/index.md
@@ -142,5 +142,3 @@ The following features are complete.
more details in the [SQL reference](reference.html)
* Local and remote JDBC drivers; see [Avatica](avatica_overview.html)
* Several [adapters](adapter.html)
-
-
diff --git a/site/_docs/lattice.md b/site/_docs/lattice.md
index 790d137..9c0b635 100644
--- a/site/_docs/lattice.md
+++ b/site/_docs/lattice.md
@@ -351,4 +351,3 @@ Here are some ideas that have not yet been implemented:
data cubes efficiently</a>.
In <i>Proc. ACM SIGMOD Conf.</i>, Montreal, 1996.</li>
</ul>
-
diff --git a/site/_docs/tutorial.md b/site/_docs/tutorial.md
index 182bbc5..f12bfea 100644
--- a/site/_docs/tutorial.md
+++ b/site/_docs/tutorial.md
@@ -53,13 +53,12 @@ several important concepts:
## Download and build
-You need Java (version 8, 9 or 10) and git.
+You need Java (version 8, 9 or 10) and Git.
{% highlight bash %}
$ git clone https://github.com/apache/calcite.git
-$ cd calcite
-$ ./mvnw install -DskipTests -Dcheckstyle.skip=true
-$ cd example/csv
+$ cd calcite/example/csv
+$ ./sqlline
{% endhighlight %}
## First queries
@@ -70,7 +69,7 @@ that is included in this project.
{% highlight bash %}
$ ./sqlline
-sqlline> !connect jdbc:calcite:model=target/test-classes/model.json admin admin
+sqlline> !connect jdbc:calcite:model=src/test/resources/model.json admin admin
{% endhighlight %}
(If you are running Windows, the command is `sqlline.bat`.)
@@ -103,7 +102,7 @@ system tables are always present in Calcite, but the other
tables are
provided by the specific implementation of the schema; in this case,
the <code>EMPS</code> and <code>DEPTS</code> tables are based on the
<code>EMPS.csv</code> and <code>DEPTS.csv</code> files in the
-<code>target/test-classes</code> directory.
+<code>resources/sales</code> directory.
Let's execute some queries on those tables, to show that Calcite is providing
a full implementation of SQL. First, a table scan:
@@ -179,7 +178,7 @@ format. Here is the model:
type: 'custom',
factory: 'org.apache.calcite.adapter.csv.CsvSchemaFactory',
operand: {
- directory: 'target/test-classes/sales'
+ directory: 'sales'
}
}
]
@@ -280,7 +279,7 @@ private Table createTable(File file) {
The schema scans the directory and finds all files whose name ends
with ".csv" and creates tables for them. In this case, the directory
-is <code>target/test-classes/sales</code> and contains files
+is <code>sales</code> and contains files
<code>EMPS.csv</code> and <code>DEPTS.csv</code>, which these become
the tables <code>EMPS</code> and <code>DEPTS</code>.
@@ -314,7 +313,7 @@ Here is a schema that defines a view:
type: 'custom',
factory: 'org.apache.calcite.adapter.csv.CsvSchemaFactory',
operand: {
- directory: 'target/test-classes/sales'
+ directory: 'sales'
},
tables: [
{
@@ -379,7 +378,7 @@ There is an example in
<code>model-with-custom-table.json</code>:
type: 'custom',
factory: 'org.apache.calcite.adapter.csv.CsvTableFactory',
operand: {
- file: 'target/test-classes/sales/EMPS.csv.gz',
+ file: 'sales/EMPS.csv.gz',
flavor: "scannable"
}
}
@@ -392,7 +391,7 @@ There is an example in
<code>model-with-custom-table.json</code>:
We can query the table in the usual way:
{% highlight sql %}
-sqlline> !connect
jdbc:calcite:model=target/test-classes/model-with-custom-table.json admin admin
+sqlline> !connect
jdbc:calcite:model=src/test/resources/model-with-custom-table.json admin admin
sqlline> SELECT empno, name FROM custom_table.emps;
+--------+--------+
| EMPNO | NAME |
@@ -476,7 +475,7 @@ a subset of columns from a CSV file. Let's run the same
query against two very
similar schemas:
{% highlight sql %}
-sqlline> !connect jdbc:calcite:model=target/test-classes/model.json admin admin
+sqlline> !connect jdbc:calcite:model=src/test/resources/model.json admin admin
sqlline> explain plan for select name from emps;
+-----------------------------------------------------+
| PLAN |
@@ -484,7 +483,7 @@ sqlline> explain plan for select name from emps;
| EnumerableCalcRel(expr#0..9=[{inputs}], NAME=[$t1]) |
| EnumerableTableScan(table=[[SALES, EMPS]]) |
+-----------------------------------------------------+
-sqlline> !connect jdbc:calcite:model=target/test-classes/smart.json admin admin
+sqlline> !connect jdbc:calcite:model=src/test/resources/smart.json admin admin
sqlline> explain plan for select name from emps;
+-----------------------------------------------------+
| PLAN |
@@ -721,4 +720,3 @@ initial implementations.
There are many other ways to extend Calcite not yet described in this tutorial.
The [adapter specification](adapter.html) describes the APIs involved.
-
diff --git a/site/_posts/2019-03-26-release-1.19.0.md
b/site/_posts/2019-03-26-release-1.19.0.md
index c85a62f..b8f3802 100644
--- a/site/_posts/2019-03-26-release-1.19.0.md
+++ b/site/_posts/2019-03-26-release-1.19.0.md
@@ -31,4 +31,3 @@ is pleased to announce
[Apache Calcite release 1.19.0]({{ site.baseurl }}/docs/history.html#v1-19-0).
This release comes three months after 1.18.0. It includes more than 80
resolved issues, comprising of a few new features as well as general
improvements and bug-fixes. Among others, there have been significant
improvements in JSON query support.
-
diff --git a/site/develop/index.md b/site/develop/index.md
index ded23ea..e39e66d 100644
--- a/site/develop/index.md
+++ b/site/develop/index.md
@@ -40,16 +40,16 @@ user-friendly.
## Download source, build, and run tests
-Prerequisites are git, maven (3.5.2 or later)
-and Java (JDK 8 or later, 9 preferred) on your path.
+Prerequisites are Git,
+and Java (JDK 8 or later, 13 preferred) on your path.
-Create a local copy of the git repository, `cd` to its root directory,
-then build using maven:
+Create a local copy of the Git repository, `cd` to its root directory,
+then build using Gradle:
{% highlight bash %}
$ git clone git://github.com/apache/calcite.git
$ cd calcite
-$ mvn install
+$ ./gradlew build
{% endhighlight %}
The HOWTO describes how to
@@ -130,7 +130,7 @@ the contributor(s) involved in the discussion should:
Fork the GitHub repository, and create a branch for your feature.
Develop your feature and test cases, and make sure that
-`mvn install` succeeds. (Run extra tests if your change warrants it.)
+`./gradlew build` succeeds. (Run extra tests if your change warrants it.)
Commit your change to your branch, and use a comment that starts with
the JIRA case number, like this:
@@ -218,4 +218,3 @@ We value all contributions that help to build a vibrant
community, not just code
You can contribute by testing the code, helping verify a release,
writing documentation or the web site,
or just by answering questions on the list.
-
