Merge branch 'main' into feature_fix

Author: mergify[bot]

Cargo.lock

@@ -22,6 +22,8 @@ The function extracts a date and time from the provided string. If the argument
 
 Returns a value of Timestamp type in the format “YYYY-MM-DD hh:mm:ss.ffffff”.
 
+If the expr matches this format but does not have a time part, it is automatically extended to this pattern. The padding value is 0.
+
 ## Examples
 
 ### Using a String as Argument
@@ -46,6 +48,11 @@ SELECT TO_DATETIME('2022-01-02T01:12:00-07:00');
 
 ---
 2022-01-02 08:12:00.000000
+
+SELECT TO_DATETIME('2022-01-02T01');
+
+---
+2022-01-02 01:00:00.000000
 ```
 
 ### Using an Integer as Argument

docs/doc/30-reference/20-functions/30-datetime-functions/todatetime.md

@@ -33,8 +33,8 @@ common-grpc = { path = "../common/grpc" }
 common-macros = { path = "../common/macros" }
 common-meta-api = { path = "../meta/api" }
 common-meta-app = { path = "../meta/app" }
+common-meta-client = { path = "../meta/client" }
 common-meta-embedded = { path = "../meta/embedded" }
-common-meta-grpc = { path = "../meta/grpc" }
 common-meta-raft-store = { path = "../meta/raft-store" }
 common-meta-sled-store = { path = "../meta/sled-store" }
 common-meta-store = { path = "../meta/store" }

src/binaries/Cargo.toml

@@ -27,8 +27,8 @@ use common_meta_app::schema::DatabaseNameIdent;
 use common_meta_app::schema::GetTableReq;
 use common_meta_app::schema::TableNameIdent;
 use common_meta_app::schema::UpsertTableOptionReq;
-use common_meta_grpc::ClientHandle;
-use common_meta_grpc::MetaGrpcClient;
+use common_meta_client::ClientHandle;
+use common_meta_client::MetaGrpcClient;
 use common_meta_types::MatchSeq;
 use common_meta_types::Operation;
 use common_meta_types::UpsertKVReq;

src/binaries/metabench/main.rs

@@ -15,7 +15,7 @@
 use std::fs::File;
 use std::io::Write;
 
-use common_meta_grpc::MetaGrpcClient;
+use common_meta_client::MetaGrpcClient;
 use common_meta_types::protobuf::Empty;
 use tokio_stream::StreamExt;
 

src/binaries/metactl/grpc.rs

@@ -20,7 +20,7 @@ mod snapshot;
 use clap::Parser;
 use common_base::base::tokio;
 use common_meta_api::KVApi;
-use common_meta_grpc::MetaGrpcClient;
+use common_meta_client::MetaGrpcClient;
 use common_meta_raft_store::config::get_default_raft_advertise_host;
 use common_tracing::init_logging;
 use common_tracing::Config as LogConfig;

src/binaries/metactl/main.rs

@@ -18,8 +18,8 @@ use std::sync::Arc;
 
 use common_base::base::RuntimeTracker;
 use common_macros::databend_main;
+use common_meta_client::MIN_METASRV_SEMVER;
 use common_meta_embedded::MetaEmbedded;
-use common_meta_grpc::MIN_METASRV_SEMVER;
 use common_metrics::init_default_metrics_recorder;
 use common_tracing::set_panic_hook;
 use databend_query::api::HttpService;

src/binaries/query/main.rs

@@ -23,6 +23,9 @@ prometheus-parse = "0.2.3"
 serde = { version = "1.0.137", features = ["derive"] }
 tracing = "0.1.35"
 
+[dev-dependencies]
+anyhow = "1.0.58"
+
 [dev-dependencies.tokio]
 default-features = false
 features = ["io-util", "net", "sync", "rt-multi-thread", "macros"]

src/common/metrics/Cargo.toml

@@ -0,0 +1,132 @@
+// Copyright 2022 Datafuse Labs.
+//
+// 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.
+
+//! This mod provides mechanism to track the count of active instances of some type `T`.
+//! The count is maintained by a `Count` implementation and will be increased or decreased when a wrapper of `T` `WithCounter` is created or dropped.
+//!
+//! Example:
+//!
+//! ```ignore
+//! struct Connection{}
+//! impl Connection {
+//!     fn ping() {}
+//! }
+//!
+//! struct MyCounter{ identifier: String, }
+//! impl Count for MyCounter {/*...*/}
+//!
+//! {
+//!     let conn = WithCounter::new(Connection{}, MyCounter{}); // increase count with `MyCounter`
+//!     conn.ping();
+//! } // decrease count with `MyCounter`
+//! ```
+
+use std::ops::Deref;
+use std::ops::DerefMut;
+
+/// Defines how to report counter metrics.
+pub trait Count {
+    fn incr_count(&mut self, n: i64);
+}
+
+/// Binds a counter to a `T`.
+///
+/// It counts the number of instances of `T` with the provided counter `Count`.
+pub struct WithCount<C, T>
+where C: Count
+{
+    counter: C,
+    inner: T,
+}
+
+impl<C, T> WithCount<C, T>
+where C: Count
+{
+    pub fn new(t: T, counter: C) -> Self {
+        let mut s = Self { counter, inner: t };
+        s.counter.incr_count(1);
+        s
+    }
+
+    pub fn counter(&self) -> &C {
+        &self.counter
+    }
+}
+
+/// When being dropped, decreases the count.
+impl<C, T> Drop for WithCount<C, T>
+where C: Count
+{
+    fn drop(&mut self) {
+        self.counter.incr_count(-1);
+    }
+}
+
+/// Let an app use `WithCount` the same as using `T`.
+impl<C, T> Deref for WithCount<C, T>
+where C: Count
+{
+    type Target = T;
+
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+
+/// Let an app use `WithCount` the same as using `T`.
+impl<C, T> DerefMut for WithCount<C, T>
+where C: Count
+{
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.inner
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::sync::atomic::AtomicI64;
+    use std::sync::atomic::Ordering;
+    use std::sync::Arc;
+
+    use crate::counter::Count;
+    use crate::counter::WithCount;
+
+    struct Foo {}
+    struct Counter {
+        n: Arc<AtomicI64>,
+    }
+    impl Count for Counter {
+        fn incr_count(&mut self, n: i64) {
+            self.n.fetch_add(n, Ordering::Relaxed);
+        }
+    }
+
+    #[test]
+    fn test_with_count() -> anyhow::Result<()> {
+        let count = Arc::new(AtomicI64::new(0));
+        assert_eq!(0, count.load(Ordering::Relaxed));
+
+        {
+            let _a = WithCount::new(Foo {}, Counter { n: count.clone() });
+            assert_eq!(1, count.load(Ordering::Relaxed));
+            {
+                let _b = WithCount::new(Foo {}, Counter { n: count.clone() });
+                assert_eq!(2, count.load(Ordering::Relaxed));
+            }
+            assert_eq!(1, count.load(Ordering::Relaxed));
+        }
+        assert_eq!(0, count.load(Ordering::Relaxed));
+        Ok(())
+    }
+}

src/common/metrics/src/counter.rs

@@ -12,6 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+pub mod counter;
 mod dump;
 mod recorder;