in work

Author: waralexrom

packages/cubejs-schema-compiler/src/adapter/BaseQuery.js

@@ -996,6 +996,7 @@ export class BaseQuery {
       ungrouped: this.options.ungrouped,
       exportAnnotatedSql: false,
       preAggregationQuery: this.options.preAggregationQuery,
+      securityContext: this.contextSymbols.securityContext,
       cubestoreSupportMultistage: this.options.cubestoreSupportMultistage ?? getEnv('cubeStoreRollingWindowJoin'),
       disableExternalPreAggregations: !!this.options.disableExternalPreAggregations,
     };

packages/cubejs-schema-compiler/test/integration/postgres/sql-generation.test.ts

@@ -665,6 +665,8 @@ describe('SQL Generation', () => {
     cube('ReferenceVisitors', {
       sql: \`
         select * from \${visitors.sql()} as t
+        WHERE \${FILTER_PARAMS.ReferenceVisitors.createdAt.filter(\`(t.created_at + interval '28 day')\`)} AND
+        \${FILTER_PARAMS.ReferenceVisitors.createdAt.filter((from, to) => \`(t.created_at + interval '28 day') >= \${from} AND (t.created_at + interval '28 day') <= \${to}\`)}
       \`,
 
       measures: {
@@ -3112,7 +3114,7 @@ SELECT 1 AS revenue,  cast('2024-01-01' AS timestamp) as time UNION ALL
     );
   });
 
-  it('security context 1', async () => {
+  it('security context', async () => {
     await compiler.compile();
 
     const query = new PostgresQuery({ joinGraph, cubeEvaluator, compiler }, {

rust/cubenativeutils/src/wrappers/serializer/deserializer.rs

@@ -49,7 +49,6 @@ impl<'de, IT: InnerTypes> Deserializer<'de> for NativeSerdeDeserializer<IT> {
             let deserializer = NativeMapDeserializer::<IT>::new(val)?;
             visitor.visit_map(deserializer)
         } else {
-            panic!("des");
             Err(NativeObjSerializerError::Message(
                 "deserializer is not implemented".to_string(),
             ))

rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/filter_params_callback.rs

@@ -0,0 +1,76 @@
+use cubenativeutils::wrappers::serializer::{
+    NativeDeserialize, NativeDeserializer, NativeSerialize,
+};
+use cubenativeutils::wrappers::{inner_types::InnerTypes, NativeString};
+use cubenativeutils::wrappers::{NativeContextHolder, NativeFunction};
+use cubenativeutils::wrappers::{NativeContextHolderRef, NativeObjectHandle};
+use cubenativeutils::CubeError;
+use std::any::Any;
+use std::rc::Rc;
+
+pub trait FilterParamsCallback {
+    fn call(&self, filter_params: &Vec<String>) -> Result<String, CubeError>;
+    fn as_any(self: Rc<Self>) -> Rc<dyn Any>;
+    fn clone_to_context(
+        &self,
+        context_ref: &dyn NativeContextHolderRef,
+    ) -> Result<Rc<dyn FilterParamsCallback>, CubeError>;
+}
+
+#[derive(Clone)]
+pub struct NativeFilterParamsCallback<IT: InnerTypes> {
+    native_object: NativeObjectHandle<IT>,
+}
+
+impl<IT: InnerTypes> NativeFilterParamsCallback<IT> {
+    pub fn new(native_object: NativeObjectHandle<IT>) -> Self {
+        Self { native_object }
+    }
+}
+
+impl<IT: InnerTypes> FilterParamsCallback for NativeFilterParamsCallback<IT> {
+    fn call(&self, filter_params: &Vec<String>) -> Result<String, CubeError> {
+        let func = self.native_object.to_function()?;
+        let context = NativeContextHolder::<IT>::new(self.native_object.get_context());
+        let args = filter_params
+            .iter()
+            .map(|param| param.to_native(context.clone()))
+            .collect::<Result<Vec<_>, _>>()?;
+        let res = func.call(args)?;
+        String::from_native(res).map_err(|_| {
+            CubeError::user("Callback for FILTER_PARAMS should return string".to_string())
+        })
+    }
+
+    fn as_any(self: Rc<Self>) -> Rc<dyn Any> {
+        self
+    }
+    fn clone_to_context(
+        &self,
+        context_ref: &dyn NativeContextHolderRef,
+    ) -> Result<Rc<dyn FilterParamsCallback>, CubeError> {
+        Ok(Rc::new(Self {
+            native_object: self.native_object.try_clone_to_context_ref(context_ref)?,
+        }))
+    }
+}
+
+impl<IT: InnerTypes> NativeSerialize<IT> for NativeFilterParamsCallback<IT> {
+    fn to_native(
+        &self,
+        _context: NativeContextHolder<IT>,
+    ) -> Result<NativeObjectHandle<IT>, CubeError> {
+        Ok(self.native_object.clone())
+    }
+}
+impl<IT: InnerTypes> NativeDeserialize<IT> for NativeFilterParamsCallback<IT> {
+    fn from_native(native_object: NativeObjectHandle<IT>) -> Result<Self, CubeError> {
+        Ok(Self::new(native_object))
+    }
+}
+
+impl<IT: InnerTypes> std::fmt::Debug for NativeFilterParamsCallback<IT> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "NativeFilterParamsCallback")
+    }
+}