🔥 Remove statical linking of PRQL

PRQL is a rust library that offers an alternative to SQL.
Because it's written with rust, it causes a lot of issues with statical linking.
This commit removes the statical linking of PRQL and instead uses the prqlc binary to compile the PRQL queries.

Due to this change, users are now required to install the prqlc binary to compile the PRQL queries.
Documentation has therefore been updated to reflect this change.

Also, thanks to this changes, it's now easier to compile anyquery for Linux.
.goreleaser.yaml doesn't use an external VM anymore to compile for Linux
and now uses the zig cc compiler.

Author: julien040

.goreleaser.yaml

@@ -42,28 +42,25 @@ builds:
         goarch: arm64
 
   - id: linux
-    gobinary: ./orbstack_go.sh
     tags:
       - vtable
       - fts5
       - sqlite_json
       - sqlite_math_functions
-      - prql
 
     ldflags:
       - -s -w
       - -X "main.version={{.Version}}"
     env:
       - CGO_ENABLED=1
-      - "ORBENV=CGO_ENABLED:CC:CGO_CFLAGS:CGO_LDFLAGS:GOOS:GOARCH"
       - CGO_CFLAGS=-O2
       - >-
         {{- if eq .Os "linux" }}
-          {{- if eq .Arch "amd64" }}CC=musl-gcc{{- end }}
-          {{- if eq .Arch "arm64" }}CC=aarch64-linux-gnu-gcc{{- end }}
+          {{- if eq .Arch "amd64" }}CC=zig cc -target x86_64-linux-musl{{- end }}
+          {{- if eq .Arch "arm64" }}CC=zig cc -target aarch64-linux-musl{{- end }}
         {{- end }}
-      - >-
-        {{- if eq .Arch "amd64" }}CGO_LDFLAGS=-static{{- end }}
+      # - >-
+      #   {{- if eq .Arch "amd64" }}CGO_LDFLAGS=-static{{- end }}
 
     goos:
       - linux

cmd/query.go

@@ -48,6 +48,6 @@ func init() {
 
 	// Alternative language flags
 	queryCmd.Flags().String("language", "", "Alternative language to use")
-	queryCmd.Flags().Bool("prql", false, "Use the PRQL language")
+	queryCmd.Flags().Bool("prql", false, "Use the PRQL language (requires prqlc in PATH)")
 	queryCmd.Flags().Bool("pql", false, "Use the PQL language")
 }

cmd/root.go

@@ -58,6 +58,6 @@ func init() {
 
 	// Alternative language flags
 	rootCmd.Flags().String("language", "", "Alternative language to use")
-	rootCmd.Flags().Bool("prql", false, "Use the PRQL language")
+	rootCmd.Flags().Bool("prql", false, "Use the PRQL language (requires prqlc in PATH)")
 	rootCmd.Flags().Bool("pql", false, "Use the PQL language")
 }

makefile

@@ -13,9 +13,6 @@ BUILD_FLAGS := "-ldflags=-s -w"
 all: $(FILES)
 	go build -o main.out -tags "$(TAGS)" $(BUILD_FLAGS) $(FILES)
 
-prql: $(FILES)
-	go build -o main.out -tags "$(TAGS) prql" $(BUILD_FLAGS) $(FILES)
-
 clean:
 	rm -f main.out
 

orbstack_go.sh

@@ -1,62 +1,32 @@
-//go:build prql
-
 package prql
 
-// #cgo CFLAGS: -I.
-// #cgo darwin,arm64 LDFLAGS: -L${SRCDIR} -lprqlc-aarch64-apple-darwin
-// #cgo darwin,amd64 LDFLAGS: -L${SRCDIR} -lprqlc-x86_64-apple-darwin
-// #cgo linux,arm64 LDFLAGS: -L${SRCDIR} -lprqlc-aarch64-unknown-linux-musl
-// #cgo linux,amd64 LDFLAGS: -L${SRCDIR} -lprqlc-x86_64-unknown-linux-musl -lm
-// #cgo windows,amd64 LDFLAGS: -L${SRCDIR} -lprqlc-x86_64-pc-windows-gnu -lws2_32 -luserenv -lntdll
-/*#include <stdlib.h>
-#include "prqlc.h"
-
-Options global_options = {
-	false, // Remove the pretty print
-	"sql.sqlite", // The dialect to use
-	false // Remove the trailing comments
-};
-
-CompileResult to_sql(char *prql_query) {
-	return compile(prql_query, &global_options);
-}
-
-*/
-import "C"
-
 import (
-	"unsafe"
+	"fmt"
+	"os/exec"
+	"strings"
 )
 
+// Calls the prqlc CLI to compile the PRQL query to SQL
 func ToSQL(prqlQuery string) (string, []CompileMessage) {
-	res := C.to_sql(C.CString(prqlQuery))
-	a := res.messages
-	if res.messages_len > 0 {
-		messages := make([]CompileMessage, res.messages_len)
-		// Convert the messages
-		for i := 0; i < int(res.messages_len); i++ {
-			message := (*C.struct_Message)(unsafe.Pointer(uintptr(unsafe.Pointer(a)) + uintptr(i)*unsafe.Sizeof(*res.messages)))
-			compileMessage := CompileMessage{}
-			if message.code != nil && *message.code != nil {
-				compileMessage.ErrorCode = rune(**message.code)
-			}
-
-			if message.display != nil && *message.display != nil {
-				compileMessage.Display = C.GoString(*message.display)
-			}
-
-			if message.location != nil {
-				compileMessage.LocationError.StartLine = int(message.location.start_line)
-				compileMessage.LocationError.StartColumn = int(message.location.start_col)
-				compileMessage.LocationError.EndLine = int(message.location.end_line)
-				compileMessage.LocationError.EndColumn = int(message.location.end_col)
-			}
-
-			messages[i] = compileMessage
-
-		}
+	_, err := exec.LookPath("prqlc")
+	if err != nil {
+		return "", []CompileMessage{{
+			ErrorCode: 'E',
+			Display:   "prqlc not found in PATH.\nMake sure it is installed: https://prql-lang.org/book/project/integrations/prqlc-cli.html#installation",
+		}}
+	}
 
-		return "", messages
+	//  prqlc compile --target sql.sqlite"
+	cmd := exec.Command("prqlc")
+	cmd.Args = append(cmd.Args, "compile", "--target", "sql.sqlite")
+	cmd.Stdin = strings.NewReader(prqlQuery)
+	out, err := cmd.CombinedOutput()
+	if err != nil {
+		return "", []CompileMessage{{
+			ErrorCode: 'E',
+			Display:   fmt.Sprintf("prqlc failed with error %s: %s", err, string(out)),
+		}}
 	}
-	return C.GoString(res.output), nil
+
+	return string(out), nil
 }