This is an automated email from the ASF dual-hosted git repository.
paleolimbot pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/arrow-nanoarrow.git
The following commit(s) were added to refs/heads/main by this push:
new 5eccbdd [C][R] Port release verification script (#78)
5eccbdd is described below
commit 5eccbdd1cdcfaafd0493d96283963dc73dfa4b59
Author: Dewey Dunnington <[email protected]>
AuthorDate: Fri Dec 2 12:11:34 2022 -0400
[C][R] Port release verification script (#78)
* add version information
* expose version in the R package
* draft port of verification script
* update example
* release verification script runs locally
* document, maybe run RC verification on CI
* maybe fix RC script
* maybe install latex
* test version info
* make better use of show_info
* more probable DIST_URL
* maybe better GHA output
* maybe try with apt-get update?
---
.github/workflows/build-and-test.yaml | 1 +
.github/workflows/verify-source.yaml | 74 +++++
CMakeLists.txt | 10 +-
dev/release/verify-release-candidate.sh | 326 +++++++++++++++++++++
r/NAMESPACE | 2 +-
r/R/nanoarrow-package.R | 8 +-
...{nanoarrow_build_id.Rd => nanoarrow_version.Rd} | 8 +-
r/src/init.c | 8 +-
r/src/{build_id.c => version.c} | 8 +-
r/tests/testthat/test-nanoarrow-package.R | 6 +-
src/nanoarrow/build_id.h.in | 9 +
src/nanoarrow/nanoarrow.h | 9 +
src/nanoarrow/utils.c | 4 +
src/nanoarrow/utils_test.cc | 5 +
14 files changed, 456 insertions(+), 22 deletions(-)
diff --git a/.github/workflows/build-and-test.yaml
b/.github/workflows/build-and-test.yaml
index 0928563..6c8a48c 100644
--- a/.github/workflows/build-and-test.yaml
+++ b/.github/workflows/build-and-test.yaml
@@ -52,6 +52,7 @@ jobs:
- name: Install dependencies
run: |
+ sudo apt-get update
sudo apt install -y -V ca-certificates lsb-release wget cmake
valgrind
wget https://apache.jfrog.io/artifactory/arrow/$(lsb_release --id
--short | tr 'A-Z' 'a-z')/apache-arrow-apt-source-latest-$(lsb_release
--codename --short).deb
sudo apt-get install -y -V
./apache-arrow-apt-source-latest-$(lsb_release --codename --short).deb
diff --git a/.github/workflows/verify-source.yaml
b/.github/workflows/verify-source.yaml
new file mode 100644
index 0000000..3831553
--- /dev/null
+++ b/.github/workflows/verify-source.yaml
@@ -0,0 +1,74 @@
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements. See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership. The ASF licenses this file
+# to you 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.
+
+on:
+ push:
+ branches:
+ - main
+ pull_request:
+ branches:
+ - main
+ paths:
+ - 'CMakeLists.txt'
+ - '.github/workflows/verify-source.yaml'
+ - 'dev/release/verify-release-candidate.sh'
+ - 'src/nanoarrow/**'
+
+name: Release Candidate Verification
+
+jobs:
+ verify-rc:
+ runs-on: ubuntu-latest
+ name: ${{ matrix.config.label }}
+
+ steps:
+ - name: Checkout repo
+ uses: actions/checkout@v3
+ with:
+ path: src
+ fetch-depth: 0
+
+ - name: Install dependencies
+ run: |
+ sudo apt-get update
+ sudo apt install -y -V ca-certificates lsb-release wget cmake
+ wget https://apache.jfrog.io/artifactory/arrow/$(lsb_release --id
--short | tr 'A-Z' 'a-z')/apache-arrow-apt-source-latest-$(lsb_release
--codename --short).deb
+ sudo apt-get install -y -V
./apache-arrow-apt-source-latest-$(lsb_release --codename --short).deb
+ sudo apt-get update
+ sudo apt-get install -y -V libarrow-dev
+ rm apache-arrow-apt-*.deb
+
+ # Needed for R source verification
+ - uses: r-lib/actions/setup-tinytex@v2
+ - uses: r-lib/actions/setup-pandoc@v2
+ - uses: r-lib/actions/setup-r@v2
+ with:
+ use-public-rspm: true
+
+ - name: Run dev/release/verify-release-candidate.sh
+ run: |
+ mkdir nanoarrow-verify-tmp
+ export NANOARROW_TMPDIR=`pwd`/nanoarrow-verify-tmp
+ cd src/dev/release
+ ./verify-release-candidate.sh
+
+ - name: Upload temp directory
+ if: failure()
+ uses: actions/upload-artifact@main
+ with:
+ path: nanoarrow-verify-tmp
+ name: nanoarrow-verify-tmp
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 64f14cf..2bea056 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -16,9 +16,15 @@
# under the License.
message(STATUS "Building using CMake version: ${CMAKE_VERSION}")
-cmake_minimum_required(VERSION 3.14)
+cmake_minimum_required(VERSION 3.16)
-project(NanoArrow)
+set(NANOARROW_VERSION "0.1.0-SNAPSHOT")
+string(REGEX MATCH "^[0-9]+\\.[0-9]+\\.[0-9]+" NANOARROW_BASE_VERSION
"${NANOARROW_VERSION}")
+project(nanoarrow VERSION "${NANOARROW_BASE_VERSION}")
+
+set(NANOARROW_VERSION_MAJOR "${nanoarrow_VERSION_MAJOR}")
+set(NANOARROW_VERSION_MINOR "${nanoarrow_VERSION_MINOR}")
+set(NANOARROW_VERSION_PATCH "${nanoarrow_VERSION_PATCH}")
option(NANOARROW_BUILD_TESTS "Build tests" OFF)
option(NANOARROW_BUNDLE "Create bundled nanoarrow.h and nanoarrow.c" OFF)
diff --git a/dev/release/verify-release-candidate.sh
b/dev/release/verify-release-candidate.sh
new file mode 100755
index 0000000..b7cd1f8
--- /dev/null
+++ b/dev/release/verify-release-candidate.sh
@@ -0,0 +1,326 @@
+#!/usr/bin/env bash
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements. See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership. The ASF licenses this file
+# to you 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.
+#
+# Requirements
+# - cmake >= 3.16
+# - R >= 3.5.0
+# - Arrow C++ >= 10.0.0
+#
+# Environment Variables
+# - NANOARROW_CMAKE_OPTIONS (e.g., to help cmake find Arrow C++)
+# - R_HOME: Path to the desired R installation. Defaults to `R` on PATH.
+# - TEST_SOURCE: Set to 0 to selectively run component verification.
+# - TEST_C: Builds the C library and tests using the default CMake
+# configuration. Defaults to the value of TEST_SOURCE.
+# - TEST_C_BUNDLED: Bundles and builds the nanoarrow.h/nanorrow.c distribution
+# and runs tests. Defaults to the value of TEST_SOURCE.
+# - TEST_R: Builds the R package source tarball and runs R CMD check.
+# Defaults to the value of TEST_SOURCE.
+
+set -e
+set -o pipefail
+
+if [ ${VERBOSE:-0} -gt 0 ]; then
+ set -x
+fi
+
+case $# in
+ 0) VERSION="HEAD"
+ SOURCE_KIND="local"
+ TEST_BINARIES=0
+ ;;
+ 1) VERSION="$1"
+ SOURCE_KIND="git"
+ TEST_BINARIES=0
+ ;;
+ 2) VERSION="$1"
+ RC_NUMBER="$2"
+ SOURCE_KIND="tarball"
+ ;;
+ *) echo "Usage:"
+ echo " Verify release candidate:"
+ echo " $0 X.Y.Z RC_NUMBER"
+ echo " Verify only the source distribution:"
+ echo " TEST_DEFAULT=0 TEST_SOURCE=1 $0 X.Y.Z RC_NUMBER"
+ echo ""
+ echo " Run the source verification tasks on a remote git revision:"
+ echo " $0 GIT-REF"
+ echo " Run the source verification tasks on this nanoarrow checkout:"
+ echo " $0"
+ exit 1
+ ;;
+esac
+
+# Note that these point to the current verify-release-candidate.sh directories
+# which is different from the NANOARROW_SOURCE_DIR set in
ensure_source_directory()
+SOURCE_DIR="$(cd "$(dirname "${BASH_SOURCE[0]:-$0}")" && pwd)"
+NANOARROW_DIR="$(cd "${SOURCE_DIR}/../.." && pwd)"
+
+show_header() {
+ if [ -z "$GITHUB_WORKSPACE" ]; then
+ echo ""
+ printf '=%.0s' $(seq ${#1}); printf '\n'
+ echo "${1}"
+ printf '=%.0s' $(seq ${#1}); printf '\n'
+ else
+ echo "::group::${1}"; printf '\n'
+ fi
+}
+
+show_info() {
+ echo "└ ${1}"
+}
+
+NANOARROW_DIST_URL='https://dist.apache.org/repos/dist/dev/arrow'
+
+download_dist_file() {
+ curl \
+ --silent \
+ --show-error \
+ --fail \
+ --location \
+ --remote-name $NANOARROW_DIST_URL/$1
+}
+
+download_rc_file() {
+ download_dist_file apache-arrow-nanoarrow-${VERSION}-rc${RC_NUMBER}/$1
+}
+
+import_gpg_keys() {
+ if [ "${GPGKEYS_ALREADY_IMPORTED:-0}" -gt 0 ]; then
+ return 0
+ fi
+ download_dist_file KEYS
+ gpg --import KEYS
+
+ GPGKEYS_ALREADY_IMPORTED=1
+}
+
+if type shasum >/dev/null 2>&1; then
+ sha256_verify="shasum -a 256 -c"
+ sha512_verify="shasum -a 512 -c"
+else
+ sha256_verify="sha256sum -c"
+ sha512_verify="sha512sum -c"
+fi
+
+fetch_archive() {
+ import_gpg_keys
+
+ local dist_name=$1
+ download_rc_file ${dist_name}.tar.gz
+ download_rc_file ${dist_name}.tar.gz.asc
+ download_rc_file ${dist_name}.tar.gz.sha256
+ download_rc_file ${dist_name}.tar.gz.sha512
+ gpg --verify ${dist_name}.tar.gz.asc ${dist_name}.tar.gz
+ ${sha256_verify} ${dist_name}.tar.gz.sha256
+ ${sha512_verify} ${dist_name}.tar.gz.sha512
+}
+
+verify_dir_artifact_signatures() {
+ import_gpg_keys
+
+ # verify the signature and the checksums of each artifact
+ find $1 -name '*.asc' | while read sigfile; do
+ artifact=${sigfile/.asc/}
+ gpg --verify $sigfile $artifact || exit 1
+
+ # go into the directory because the checksum files contain only the
+ # basename of the artifact
+ pushd $(dirname $artifact)
+ base_artifact=$(basename $artifact)
+ if [ -f $base_artifact.sha256 ]; then
+ ${sha256_verify} $base_artifact.sha256 || exit 1
+ fi
+ if [ -f $base_artifact.sha512 ]; then
+ ${sha512_verify} $base_artifact.sha512 || exit 1
+ fi
+ popd
+ done
+}
+
+setup_tempdir() {
+ cleanup() {
+ if [ "${TEST_SUCCESS}" = "yes" ]; then
+ rm -fr "${NANOARROW_TMPDIR}"
+ else
+ echo "Failed to verify release candidate. See ${NANOARROW_TMPDIR} for
details."
+ fi
+ }
+
+ show_header "Creating temporary directory"
+
+ if [ -z "${NANOARROW_TMPDIR}" ]; then
+ # clean up automatically if NANOARROW_TMPDIR is not defined
+ NANOARROW_TMPDIR=$(mktemp -d -t "nanoarrow-${VERSION}.XXXXX")
+ trap cleanup EXIT
+ else
+ # don't clean up automatically
+ mkdir -p "${NANOARROW_TMPDIR}"
+ fi
+
+ echo "Working in sandbox ${NANOARROW_TMPDIR}"
+}
+
+test_and_install_c() {
+ show_header "Build, install, and test C library"
+
+ mkdir -p $NANOARROW_TMPDIR/build
+ pushd $NANOARROW_TMPDIR/build
+
+ show_info "Configure CMake Project"
+ cmake ${NANOARROW_SOURCE_DIR} \
+ -DNANOARROW_BUILD_TESTS=ON \
+ ${NANOARROW_CMAKE_OPTIONS:-}
+
+ show_info "Build CMake Project"
+ cmake --build .
+
+ show_info "Install CMake Project"
+ cmake --install . --prefix=$NANOARROW_HOME
+
+ show_info "Run Tests"
+ ctest --output-on-failure
+
+ popd
+}
+
+test_c_bundled() {
+ show_header "Build test C library"
+
+ mkdir -p $NANOARROW_TMPDIR/build_bundled
+ pushd $NANOARROW_TMPDIR/build_bundled
+
+ show_info "Configure CMake Project"
+ cmake ${NANOARROW_SOURCE_DIR} \
+ -DNANOARROW_BUILD_TESTS=ON \
+ -DNANOARROW_BUNDLE=ON \
+ ${NANOARROW_CMAKE_OPTIONS:-}
+
+ show_info "Build CMake Project"
+ cmake --build .
+
+ show_info "Run Tests"
+ ctest --output-on-failure
+
+ popd
+}
+
+test_r() {
+ show_header "Build and test R package"
+
+ if [ ! -z "${R_HOME}" ]; then
+ R_BIN=${R_HOME}/bin/R
+ else
+ R_BIN=R
+ fi
+
+ show_info "Install nanoarrow test dependencies"
+ $R_BIN -e 'install.packages("pak", repos = "https://cloud.r-project.org";);
pak::local_install_dev_deps("r")'
+
+ show_info "Build the R package source tarball"
+ pushd r
+ ./configure
+ popd
+
+ # Builds the R source tarball
+ pushd $NANOARROW_TMPDIR
+ $R_BIN CMD build $NANOARROW_SOURCE_DIR/r
+ R_PACKAGE_TARBALL_NAME=`ls nanoarrow_*.tar.gz`
+
+ show_info "Run R CMD check"
+ # Runs R CMD check on the tarball
+ $R_BIN CMD check $R_PACKAGE_TARBALL_NAME
+
+ popd
+}
+
+ensure_source_directory() {
+ show_header "Ensuring source directory"
+
+ dist_name="apache-arrow-nanoarrow-${VERSION}"
+
+ if [ "${SOURCE_KIND}" = "local" ]; then
+ # Local nanoarrow repository
+ if [ -z "$NANOARROW_SOURCE_DIR" ]; then
+ export NANOARROW_SOURCE_DIR="${NANOARROW_DIR}"
+ fi
+ echo "Verifying local nanoarrow checkout at ${NANOARROW_SOURCE_DIR}"
+ elif [ "${SOURCE_KIND}" = "git" ]; then
+ # Remote nanoarrow repository
+ : ${SOURCE_REPOSITORY:="https://github.com/apache/arrow-nanoarrow"}
+ echo "Verifying nanoarrow repository ${SOURCE_REPOSITORY} with revision
checkout ${VERSION}"
+ export NANOARROW_SOURCE_DIR="${NANOARROW_TMPDIR}/arrow-nanoarrow"
+ if [ ! -d "${NANOARROW_SOURCE_DIR}" ]; then
+ git clone --recurse-submodules $SOURCE_REPOSITORY $NANOARROW_SOURCE_DIR
+ git -C $NANOARROW_SOURCE_DIR checkout $VERSION
+ fi
+ else
+ # Release tarball
+ echo "Verifying official nanoarrow release candidate
${VERSION}-rc${RC_NUMBER}"
+ export NANOARROW_SOURCE_DIR="${NANOARROW_TMPDIR}/${dist_name}"
+ if [ ! -d "${NANOARROW_SOURCE_DIR}" ]; then
+ pushd $NANOARROW_TMPDIR
+ fetch_archive ${dist_name}
+ tar xf ${dist_name}.tar.gz
+ popd
+ fi
+ fi
+}
+
+
+test_source_distribution() {
+ export NANOARROW_HOME=$NANOARROW_TMPDIR/install
+ pushd $NANOARROW_SOURCE_DIR
+
+ if [ ${TEST_C} -gt 0 ]; then
+ test_and_install_c
+ fi
+
+ if [ ${TEST_C_BUNDLED} -gt 0 ]; then
+ test_c_bundled
+ fi
+
+ if [ ${TEST_R} -gt 0 ]; then
+ test_r
+ fi
+
+ popd
+}
+
+# By default test all functionalities.
+# To deactivate one test, deactivate the test and all of its dependents
+# To explicitly select one test, set TEST_DEFAULT=0 TEST_X=1
+: ${TEST_DEFAULT:=1}
+
+: ${TEST_SOURCE:=${TEST_DEFAULT}}
+: ${TEST_C:=${TEST_SOURCE}}
+: ${TEST_C_BUNDLED:=${TEST_SOURCE}}
+: ${TEST_R:=${TEST_SOURCE}}
+
+TEST_SUCCESS=no
+
+setup_tempdir
+ensure_source_directory
+test_source_distribution
+
+TEST_SUCCESS=yes
+
+echo "Release candidate ${VERSION}-RC${RC_NUMBER} looks good!"
+exit 0
diff --git a/r/NAMESPACE b/r/NAMESPACE
index 6bfd421..1213a36 100644
--- a/r/NAMESPACE
+++ b/r/NAMESPACE
@@ -56,7 +56,6 @@ export(infer_nanoarrow_schema)
export(nanoarrow_allocate_array)
export(nanoarrow_allocate_array_stream)
export(nanoarrow_allocate_schema)
-export(nanoarrow_build_id)
export(nanoarrow_pointer_addr_chr)
export(nanoarrow_pointer_addr_dbl)
export(nanoarrow_pointer_addr_pretty)
@@ -65,6 +64,7 @@ export(nanoarrow_pointer_is_valid)
export(nanoarrow_pointer_move)
export(nanoarrow_pointer_release)
export(nanoarrow_schema_parse)
+export(nanoarrow_version)
importFrom(utils,getFromNamespace)
importFrom(utils,str)
useDynLib(nanoarrow, .registration = TRUE)
diff --git a/r/R/nanoarrow-package.R b/r/R/nanoarrow-package.R
index aba93dd..4c5511a 100644
--- a/r/R/nanoarrow-package.R
+++ b/r/R/nanoarrow-package.R
@@ -34,12 +34,12 @@ NULL
#' @export
#'
#' @examples
-#' nanoarrow_build_id()
+#' nanoarrow_version()
#'
-nanoarrow_build_id <- function(runtime = TRUE) {
+nanoarrow_version <- function(runtime = TRUE) {
if (runtime) {
- .Call(nanoarrow_c_build_id_runtime)
+ .Call(nanoarrow_c_version_runtime)
} else {
- .Call(nanoarrow_c_build_id)
+ .Call(nanoarrow_c_version)
}
}
diff --git a/r/man/nanoarrow_build_id.Rd b/r/man/nanoarrow_version.Rd
similarity index 78%
rename from r/man/nanoarrow_build_id.Rd
rename to r/man/nanoarrow_version.Rd
index cdeaf33..18f9efc 100644
--- a/r/man/nanoarrow_build_id.Rd
+++ b/r/man/nanoarrow_version.Rd
@@ -1,10 +1,10 @@
% Generated by roxygen2: do not edit by hand
% Please edit documentation in R/nanoarrow-package.R
-\name{nanoarrow_build_id}
-\alias{nanoarrow_build_id}
+\name{nanoarrow_version}
+\alias{nanoarrow_version}
\title{Underlying 'nanoarrow' C library build}
\usage{
-nanoarrow_build_id(runtime = TRUE)
+nanoarrow_version(runtime = TRUE)
}
\arguments{
\item{runtime}{Compare TRUE and FALSE values to detect a
@@ -18,6 +18,6 @@ was compiled against.
Underlying 'nanoarrow' C library build
}
\examples{
-nanoarrow_build_id()
+nanoarrow_version()
}
diff --git a/r/src/init.c b/r/src/init.c
index 33c40ed..1827fe7 100644
--- a/r/src/init.c
+++ b/r/src/init.c
@@ -35,8 +35,6 @@ extern SEXP nanoarrow_c_infer_schema_array(SEXP array_xptr);
extern SEXP nanoarrow_c_array_proxy(SEXP array_xptr, SEXP array_view_xptr,
SEXP recursive_sexp);
extern SEXP nanoarrow_c_buffer_info(SEXP buffer_xptr);
extern SEXP nanoarrow_c_buffer_as_raw(SEXP buffer_xptr);
-extern SEXP nanoarrow_c_build_id(void);
-extern SEXP nanoarrow_c_build_id_runtime(void);
extern SEXP nanoarrow_c_convert_array_stream(SEXP array_stream_xptr, SEXP
ptype_sexp, SEXP size_sexp, SEXP n_sexp);
extern SEXP nanoarrow_c_convert_array(SEXP array_xptr, SEXP ptype_sexp);
extern SEXP nanoarrow_c_infer_ptype(SEXP schema_xptr);
@@ -55,6 +53,8 @@ extern SEXP nanoarrow_c_export_array(SEXP array_xptr, SEXP
ptr_dst);
extern SEXP nanoarrow_c_schema_to_list(SEXP schema_xptr);
extern SEXP nanoarrow_c_schema_parse(SEXP schema_xptr);
extern SEXP nanoarrow_c_schema_format(SEXP schema_xptr, SEXP recursive_sexp);
+extern SEXP nanoarrow_c_version();
+extern SEXP nanoarrow_c_version_runtime();
static const R_CallMethodDef CallEntries[] = {
{"nanoarrow_c_make_altrep_chr", (DL_FUNC)&nanoarrow_c_make_altrep_chr, 1},
@@ -69,8 +69,6 @@ static const R_CallMethodDef CallEntries[] = {
{"nanoarrow_c_array_proxy", (DL_FUNC)&nanoarrow_c_array_proxy, 3},
{"nanoarrow_c_buffer_info", (DL_FUNC)&nanoarrow_c_buffer_info, 1},
{"nanoarrow_c_buffer_as_raw", (DL_FUNC)&nanoarrow_c_buffer_as_raw, 1},
- {"nanoarrow_c_build_id", (DL_FUNC)&nanoarrow_c_build_id, 0},
- {"nanoarrow_c_build_id_runtime", (DL_FUNC)&nanoarrow_c_build_id_runtime,
0},
{"nanoarrow_c_convert_array_stream",
(DL_FUNC)&nanoarrow_c_convert_array_stream, 4},
{"nanoarrow_c_convert_array", (DL_FUNC)&nanoarrow_c_convert_array, 2},
{"nanoarrow_c_infer_ptype", (DL_FUNC)&nanoarrow_c_infer_ptype, 1},
@@ -89,6 +87,8 @@ static const R_CallMethodDef CallEntries[] = {
{"nanoarrow_c_schema_to_list", (DL_FUNC)&nanoarrow_c_schema_to_list, 1},
{"nanoarrow_c_schema_parse", (DL_FUNC)&nanoarrow_c_schema_parse, 1},
{"nanoarrow_c_schema_format", (DL_FUNC)&nanoarrow_c_schema_format, 2},
+ {"nanoarrow_c_version", (DL_FUNC)&nanoarrow_c_version, 0},
+ {"nanoarrow_c_version_runtime", (DL_FUNC)&nanoarrow_c_version_runtime, 0},
{NULL, NULL, 0}};
/* end generated by tools/make-callentries.R */
diff --git a/r/src/build_id.c b/r/src/version.c
similarity index 84%
rename from r/src/build_id.c
rename to r/src/version.c
index 32166de..0318cae 100644
--- a/r/src/build_id.c
+++ b/r/src/version.c
@@ -21,10 +21,10 @@
#include "nanoarrow.h"
-SEXP nanoarrow_c_build_id(void) {
- return Rf_mkString(NANOARROW_BUILD_ID);
+SEXP nanoarrow_c_version() {
+ return Rf_mkString(NANOARROW_VERSION);
}
-SEXP nanoarrow_c_build_id_runtime(void) {
- return Rf_mkString(ArrowNanoarrowBuildId());
+SEXP nanoarrow_c_version_runtime() {
+ return Rf_mkString(ArrowNanoarrowVersion());
}
diff --git a/r/tests/testthat/test-nanoarrow-package.R
b/r/tests/testthat/test-nanoarrow-package.R
index e0bb3cb..0427b34 100644
--- a/r/tests/testthat/test-nanoarrow-package.R
+++ b/r/tests/testthat/test-nanoarrow-package.R
@@ -15,9 +15,9 @@
# specific language governing permissions and limitations
# under the License.
-test_that("nanoarrow_build_id() works", {
+test_that("nanoarrow_version() works", {
expect_identical(
- nanoarrow_build_id(runtime = TRUE),
- nanoarrow_build_id(runtime = FALSE)
+ nanoarrow_version(runtime = TRUE),
+ nanoarrow_version(runtime = FALSE)
)
})
diff --git a/src/nanoarrow/build_id.h.in b/src/nanoarrow/build_id.h.in
index 536cf60..b0cf0de 100644
--- a/src/nanoarrow/build_id.h.in
+++ b/src/nanoarrow/build_id.h.in
@@ -18,6 +18,15 @@
#ifndef NANOARROW_BUILD_ID_H_INCLUDED
#define NANOARROW_BUILD_ID_H_INCLUDED
+#define NANOARROW_VERSION_MAJOR @NANOARROW_VERSION_MAJOR@
+#define NANOARROW_VERSION_MINOR @NANOARROW_VERSION_MINOR@
+#define NANOARROW_VERSION_PATCH @NANOARROW_VERSION_PATCH@
+#define NANOARROW_VERSION "@NANOARROW_VERSION@"
+
+#define NANOARROW_VERSION_INT \
+ (NANOARROW_VERSION_MAJOR * 10000 + NANOARROW_VERSION_MINOR * 100 + \
+ NANOARROW_VERSION_PATCH)
+
@NANOARROW_NAMESPACE_DEFINE@
#define NANOARROW_BUILD_ID "@NANOARROW_BUILD_ID@"
diff --git a/src/nanoarrow/nanoarrow.h b/src/nanoarrow/nanoarrow.h
index 6d2c059..4dc8e68 100644
--- a/src/nanoarrow/nanoarrow.h
+++ b/src/nanoarrow/nanoarrow.h
@@ -36,6 +36,9 @@
#define NANOARROW_SYMBOL(A, B) NANOARROW_CAT(A, B)
#define ArrowNanoarrowBuildId NANOARROW_SYMBOL(NANOARROW_NAMESPACE,
ArrowNanoarrowBuildId)
+#define ArrowNanoarrowVersion NANOARROW_SYMBOL(NANOARROW_NAMESPACE,
ArrowNanoarrowVersion)
+#define ArrowNanoarrowVersionInt \
+ NANOARROW_SYMBOL(NANOARROW_NAMESPACE, ArrowNanoarrowVersionInt)
#define ArrowErrorMessage NANOARROW_SYMBOL(NANOARROW_NAMESPACE,
ArrowErrorMessage)
#define ArrowMalloc NANOARROW_SYMBOL(NANOARROW_NAMESPACE, ArrowMalloc)
#define ArrowRealloc NANOARROW_SYMBOL(NANOARROW_NAMESPACE, ArrowRealloc)
@@ -186,6 +189,12 @@ const char* ArrowErrorMessage(struct ArrowError* error);
/// \brief Return the build id against which the library was compiled
const char* ArrowNanoarrowBuildId(void);
+/// \brief Return a version string in the form "major.minor.patch"
+const char* ArrowNanoarrowVersion();
+
+/// \brief Return an integer that can be used to compare versions sequentially
+int ArrowNanoarrowVersionInt();
+
/// \brief Initialize a description of buffer arrangements from a storage type
void ArrowLayoutInit(struct ArrowLayout* layout, enum ArrowType storage_type);
diff --git a/src/nanoarrow/utils.c b/src/nanoarrow/utils.c
index 1db2835..7df4d17 100644
--- a/src/nanoarrow/utils.c
+++ b/src/nanoarrow/utils.c
@@ -26,6 +26,10 @@
const char* ArrowNanoarrowBuildId(void) { return NANOARROW_BUILD_ID; }
+const char* ArrowNanoarrowVersion() { return NANOARROW_VERSION; }
+
+int ArrowNanoarrowVersionInt() { return NANOARROW_VERSION_INT; }
+
int ArrowErrorSet(struct ArrowError* error, const char* fmt, ...) {
if (error == NULL) {
return NANOARROW_OK;
diff --git a/src/nanoarrow/utils_test.cc b/src/nanoarrow/utils_test.cc
index 27f6393..f166400 100644
--- a/src/nanoarrow/utils_test.cc
+++ b/src/nanoarrow/utils_test.cc
@@ -29,6 +29,11 @@ TEST(BuildIdTest, BuildIdTest) {
EXPECT_STREQ(ArrowNanoarrowBuildId(), NANOARROW_BUILD_ID);
}
+TEST(BuildIdTest, VersionTest) {
+ EXPECT_STREQ(ArrowNanoarrowVersion(), NANOARROW_VERSION);
+ EXPECT_EQ(ArrowNanoarrowVersionInt(), NANOARROW_VERSION_INT);
+}
+
TEST(ErrorTest, ErrorTestSet) {
ArrowError error;
EXPECT_EQ(ArrowErrorSet(&error, "there were %d foxes", 4), NANOARROW_OK);
