refactor: implement version as built-in function and use fixed mysql version (#3133)

* refactor:  implement version as built-in function

* test: add sqlness test for version()

src/common/function/src/system.rs

@@ -13,10 +13,12 @@
 // limitations under the License.
 
 pub mod build;
+pub mod version;
 
 use std::sync::Arc;
 
 use build::BuildFunction;
+use version::VersionFunction;
 
 use crate::function_registry::FunctionRegistry;
 
@@ -25,5 +27,6 @@ pub(crate) struct SystemFunction;
 impl SystemFunction {
     pub fn register(registry: &FunctionRegistry) {
         registry.register(Arc::new(BuildFunction));
+        registry.register(Arc::new(VersionFunction));
     }
 }

src/common/function/src/system/version.rs

@@ -0,0 +1,54 @@
+// Copyright 2023 Greptime Team
+//
+// 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.
+
+use std::sync::Arc;
+use std::{env, fmt};
+
+use common_query::error::Result;
+use common_query::prelude::{Signature, Volatility};
+use datatypes::data_type::ConcreteDataType;
+use datatypes::vectors::{StringVector, VectorRef};
+
+use crate::function::{Function, FunctionContext};
+
+#[derive(Clone, Debug, Default)]
+pub(crate) struct VersionFunction;
+
+impl fmt::Display for VersionFunction {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "VERSION")
+    }
+}
+
+impl Function for VersionFunction {
+    fn name(&self) -> &str {
+        "version"
+    }
+
+    fn return_type(&self, _input_types: &[ConcreteDataType]) -> Result<ConcreteDataType> {
+        Ok(ConcreteDataType::string_datatype())
+    }
+
+    fn signature(&self) -> Signature {
+        Signature::exact(vec![], Volatility::Immutable)
+    }
+
+    fn eval(&self, _func_ctx: FunctionContext, _columns: &[VectorRef]) -> Result<VectorRef> {
+        let result = StringVector::from(vec![format!(
+            "5.7.20-greptimedb-{}",
+            env!("CARGO_PKG_VERSION")
+        )]);
+        Ok(Arc::new(result))
+    }
+}

src/servers/src/mysql/federated.rs

@@ -16,7 +16,6 @@
 //! Inspired by Databend's "[mysql_federated.rs](https://github.com/datafuselabs/databend/blob/ac706bf65845e6895141c96c0a10bad6fdc2d367/src/query/service/src/servers/mysql/mysql_federated.rs)".
 
 use std::collections::HashMap;
-use std::env;
 use std::sync::Arc;
 
 use common_query::Output;
@@ -42,8 +41,6 @@ static SHOW_COLLATION_PATTERN: Lazy<Regex> =
 static SHOW_VARIABLES_PATTERN: Lazy<Regex> =
     Lazy::new(|| Regex::new("(?i)^(SHOW VARIABLES(.*))").unwrap());
 
-static SELECT_VERSION_PATTERN: Lazy<Regex> =
-    Lazy::new(|| Regex::new(r"(?i)^(SELECT VERSION\(\s*\))").unwrap());
 static SELECT_DATABASE_PATTERN: Lazy<Regex> =
     Lazy::new(|| Regex::new(r"(?i)^(SELECT DATABASE\(\s*\))").unwrap());
 
@@ -283,9 +280,7 @@ fn check_others(query: &str, query_ctx: QueryContextRef) -> Option<Output> {
         return Some(Output::RecordBatches(RecordBatches::empty()));
     }
 
-    let recordbatches = if SELECT_VERSION_PATTERN.is_match(query) {
-        Some(select_function("version()", &get_version()))
-    } else if SELECT_DATABASE_PATTERN.is_match(query) {
+    let recordbatches = if SELECT_DATABASE_PATTERN.is_match(query) {
         let schema = query_ctx.current_schema();
         Some(select_function("database()", schema))
     } else if SELECT_TIME_DIFF_FUNC_PATTERN.is_match(query) {
@@ -321,10 +316,6 @@ pub(crate) fn check(
         .or_else(|| check_others(query, query_ctx))
 }
 
-// get GreptimeDB's version.
-fn get_version() -> String {
-    format!("{}-greptime", env!("CARGO_PKG_VERSION"))
-}
 #[cfg(test)]
 mod test {
 
@@ -356,19 +347,6 @@ mod test {
             }
         }
 
-        let query = "select version()";
-        let version = env::var("CARGO_PKG_VERSION").unwrap_or_else(|_| "unknown".to_string());
-        let output = check(query, QueryContext::arc(), session.clone());
-        match output.unwrap() {
-            Output::RecordBatches(r) => {
-                assert!(&r
-                    .pretty_print()
-                    .unwrap()
-                    .contains(&format!("{version}-greptime")));
-            }
-            _ => unreachable!(),
-        }
-
         let query = "SELECT @@version_comment LIMIT 1";
         let expected = "\
 +-------------------+

tests/cases/standalone/common/function/system.result

@@ -8,3 +8,12 @@ SELECT build();
 
 ++|build()|++|branch:BRANCH|commit:COMMIT|commitshort:COMMITSHORT|dirty:DIRTY|version:VERSION++
 
+-- SQLNESS REPLACE greptimedb-[\d\.]+ greptimedb-VERSION
+SELECT version();
+
++-------------------------+
+| version()               |
++-------------------------+
+| 5.7.20-greptimedb-VERSION |
++-------------------------+
+

tests/cases/standalone/common/function/system.sql

@@ -5,3 +5,6 @@
 -- SQLNESS REPLACE version:\s+.+ version: VERSION
 -- SQLNESS REPLACE [\s\-]+
 SELECT build();
+
+-- SQLNESS REPLACE greptimedb-[\d\.]+ greptimedb-VERSION
+SELECT version();