Use air

Author: gaborcsardi

.Rbuildignore

@@ -11,3 +11,5 @@
 ^_pkgdown.yml$
 ^vignettes/articles$
 ^src/Makevars$
+^[\.]?air\.toml$
+^\.vscode$

.vscode/extensions.json

@@ -0,0 +1,5 @@
+{
+    "recommendations": [
+        "Posit.air-vscode"
+    ]
+}

.vscode/settings.json

@@ -5,5 +5,9 @@
     },
     "clangd.arguments": [
         "-header-insertion=never"
-    ]
+    ],
+    "[r]": {
+        "editor.formatOnSave": true,
+        "editor.defaultFormatter": "Posit.air-vscode"
+    }
 }

R/arrow-schema.R

@@ -7,8 +7,14 @@ read_arrow_schema <- function(file) {
   }
 }
 
-apply_arrow_schema <- function(tab, file, arrow_schema, dicts, types,
-                               col_select) {
+apply_arrow_schema <- function(
+  tab,
+  file,
+  arrow_schema,
+  dicts,
+  types,
+  col_select
+) {
   if (is.na(arrow_schema)) {
     return(tab)
   }
@@ -19,7 +25,9 @@ apply_arrow_schema <- function(tab, file, arrow_schema, dicts, types,
   }
   for (idx in spec$difftime) {
     # only if INT64, otherwise hms, probably
-    if (types[[idx]] != 2) next
+    if (types[[idx]] != 2) {
+      next
+    }
     mult <- switch(
       spec$columns$type[[idx]]$unit,
       SECOND = 1,
@@ -37,10 +45,13 @@ arrow_find_special <- function(asch, file, col_select = NULL) {
   amd <- tryCatch(
     parse_arrow_schema(asch)$columns,
     error = function(e) {
-      warning(sprintf(
-        "Failed to parse Arrow schema from parquet file at '%s'",
-        file
-      ), call. = TRUE)
+      warning(
+        sprintf(
+          "Failed to parse Arrow schema from parquet file at '%s'",
+          file
+        ),
+        call. = TRUE
+      )
       NULL
     }
   )
@@ -98,7 +109,6 @@ float_precision_names <- c(
 date_unit_names <- c(
   DAY = 0L,
   MILLISECOND = 1L
-
 )
 
 time_unit_names <- c(
@@ -174,8 +184,12 @@ encode_arrow_schema_r <- function(df, schema) {
   dates <- vapply(df, function(c) inherits(c, "Date"), logical(1))
   hmss <- vapply(df, function(c) inherits(c, "hms"), logical(1))
   psxcts <- vapply(df, function(c) inherits(c, "POSIXct"), logical(1))
-	fctrs <- vapply(df, function(c) inherits(c, "factor"), logical(1))
-  dfts <- vapply(df, function(c) !inherits(c, "hms") && inherits(c, "difftime"), logical(1))
+  fctrs <- vapply(df, function(c) inherits(c, "factor"), logical(1))
+  dfts <- vapply(
+    df,
+    function(c) !inherits(c, "hms") && inherits(c, "difftime"),
+    logical(1)
+  )
   typemap <- c(
     "integer" = "Int",
     "double" = "FloatingPoint",
@@ -233,7 +247,8 @@ encode_arrow_schema_r <- function(df, schema) {
 
 # Replace strings with numeric IDs, so we can use them in C++
 fill_arrow_schema_enums_type <- function(type_type, type) {
-  switch(type_type,
+  switch(
+    type_type,
     "FloatingPoint" = {
       type$precision <- float_precision_names[type$precision]
     },
@@ -260,7 +275,7 @@ fill_arrow_schema_enums_type <- function(type_type, type) {
 
 fill_arrow_schema_enums_dict <- function(dict) {
   if (!is.null(dict)) {
-    dict$dictionary_kind <-dict_kind_names[dict$dictionary_kind]
+    dict$dictionary_kind <- dict_kind_names[dict$dictionary_kind]
   }
   dict
 }
@@ -283,7 +298,7 @@ fill_arrow_schema_enums <- function(schema) {
   schema
 }
 
-encode_arrow_schema<- function(df) {
+encode_arrow_schema <- function(df) {
   schema <- encode_arrow_schema_r(df)
   schema <- fill_arrow_schema_enums(schema)
   rawenc <- .Call(nanoparquet_encode_arrow_schema, schema)
@@ -295,11 +310,11 @@ encode_arrow_schema<- function(df) {
 # Arrow only supports 8, 16, 32 and 64.
 factor_bits <- function(x) {
   l <- length(levels(x))
-  if (l < 2^(8-1)) {
+  if (l < 2^(8 - 1)) {
     8L
-  } else if (l < 2^(16-1)) {
+  } else if (l < 2^(16 - 1)) {
     16L
-  } else if (l < 2^(32-1)) {
+  } else if (l < 2^(32 - 1)) {
     32L
   } else {
     64L

R/infer-parquet-schema.R

@@ -12,31 +12,31 @@
 #' @export
 
 infer_parquet_schema <- function(df, options = parquet_options()) {
-	types <- .Call(rf_nanoparquet_map_to_parquet_types, df, options)
-	lt <- unname(lapply(types, function(x) x[[3]]))
-	ct <- lapply(lt, function(x) if (!is.null(x)) logical_to_converted(x))
-	type_tab <- data.frame(
-		file_name = rep(NA_character_, length(df)),
-		name = names(df),
-		r_type = vapply(types, function(x) x[[2]], ""),
-		type = vapply(types, function(x) x[[1]], ""),
-		type_length = rep(NA_integer_, length(df)),
-		repetition_type = ifelse(vapply(df, anyNA, TRUE), "OPTIONAL", "REQUIRED"),
-		converted_type = map_chr(ct, function(x) {
-			x[["converted_type"]] %||% NA_character_
-		}),
-		logical_type = I(lt),
-		num_children = rep(NA_integer_, length(df)),
-		scale = map_int(ct, function(x) {
-			x[["scale"]] %||% NA_integer_
-		}),
-		precision = map_int(ct, function(x) {
-			x[["precision"]] %||% NA_integer_
-		}),
-		field_id = rep(NA_integer_, length(df))
-	)
+  types <- .Call(rf_nanoparquet_map_to_parquet_types, df, options)
+  lt <- unname(lapply(types, function(x) x[[3]]))
+  ct <- lapply(lt, function(x) if (!is.null(x)) logical_to_converted(x))
+  type_tab <- data.frame(
+    file_name = rep(NA_character_, length(df)),
+    name = names(df),
+    r_type = vapply(types, function(x) x[[2]], ""),
+    type = vapply(types, function(x) x[[1]], ""),
+    type_length = rep(NA_integer_, length(df)),
+    repetition_type = ifelse(vapply(df, anyNA, TRUE), "OPTIONAL", "REQUIRED"),
+    converted_type = map_chr(ct, function(x) {
+      x[["converted_type"]] %||% NA_character_
+    }),
+    logical_type = I(lt),
+    num_children = rep(NA_integer_, length(df)),
+    scale = map_int(ct, function(x) {
+      x[["scale"]] %||% NA_integer_
+    }),
+    precision = map_int(ct, function(x) {
+      x[["precision"]] %||% NA_integer_
+    }),
+    field_id = rep(NA_integer_, length(df))
+  )
 
-	rownames(type_tab) <- NULL
-	class(type_tab) <- c("tbl", class(type_tab))
-	type_tab
+  rownames(type_tab) <- NULL
+  class(type_tab) <- c("tbl", class(type_tab))
+  type_tab
 }

R/options.R

@@ -66,10 +66,16 @@ parquet_options <- function(
   class = getOption("nanoparquet.class", "tbl"),
   compression_level = getOption("nanoparquet.compression_level", NA_integer_),
   keep_row_groups = FALSE,
-  num_rows_per_row_group = getOption("nanoparquet.num_rows_per_row_group", 10000000L),
+  num_rows_per_row_group = getOption(
+    "nanoparquet.num_rows_per_row_group",
+    10000000L
+  ),
   use_arrow_metadata = getOption("nanoparquet.use_arrow_metadata", TRUE),
   write_arrow_metadata = getOption("nanoparquet.write_arrow_metadata", TRUE),
-  write_data_page_version = getOption("nanoparquet.write_data_page_version", 1L),
+  write_data_page_version = getOption(
+    "nanoparquet.write_data_page_version",
+    1L
+  ),
   write_minmax_values = getOption("nanoparquet.write_minmax_values", TRUE)
 ) {
   stopifnot(is.character(class))
@@ -78,9 +84,9 @@ parquet_options <- function(
   stopifnot(is_flag(write_arrow_metadata))
   stopifnot(
     identical(write_data_page_version, 1) ||
-    identical(write_data_page_version, 2) ||
-    identical(write_data_page_version, 1L) ||
-    identical(write_data_page_version, 2L)
+      identical(write_data_page_version, 2) ||
+      identical(write_data_page_version, 1L) ||
+      identical(write_data_page_version, 2L)
   )
   stopifnot(is_flag(write_minmax_values))
   num_rows_per_row_group <- as_count(
@@ -89,12 +95,17 @@ parquet_options <- function(
   )
   if (identical(compression_level, Inf)) {
     compression_level <- 100000L
-  } else if (identical(compression_level, NA) ||
-             identical(compression_level, NA_integer_) ||
-             identical(compression_level, NA_real_)) {
+  } else if (
+    identical(compression_level, NA) ||
+      identical(compression_level, NA_integer_) ||
+      identical(compression_level, NA_real_)
+  ) {
     compression_level <- NA_integer_
   } else {
-    compression_level <- as_integer_scalar(compression_level, "compression_level")
+    compression_level <- as_integer_scalar(
+      compression_level,
+      "compression_level"
+    )
   }
 
   list(