better

Author: myrrc

vortex-duckdb/cpp/table_function.cpp

@@ -272,31 +272,31 @@ struct CTableFunctionInfo final : TableFunctionInfo {
 struct CTableBindData final : TableFunctionData {
     CTableBindData(
         unique_ptr<CTableFunctionInfo> info_p,
-        const vector<string>& column_names,
         Session&& session,
-        DataSource&& data_source)
+        DataSource&& data_source,
+        const vector<string>& column_names)
         : info(std::move(info_p))
-        , column_names(column_names)
         , session(std::move(session))
-        , data_source(std::move(data_source)) {}
+        , data_source(std::move(data_source))
+        , column_names(column_names) {}
 
     ~CTableBindData() override = default;
 
     unique_ptr<FunctionData> Copy() const override {
         return make_uniq<CTableBindData>(
             make_uniq<CTableFunctionInfo>(info->vtab),
-            column_names,
             Session{session},
-            DataSource{data_source});
+            DataSource{data_source},
+            column_names);
     }
 
     unique_ptr<CTableFunctionInfo> info; // TODO remove
 
-    // precomputed from data_source using vx_struct_fields_field_name, see c_bind()
-    vector<string> column_names;
-
     Session session;
     DataSource data_source;
+
+    vector<string> column_names;
+    vector<const vx_expression*> filters;
 };
 
 struct CTableGlobalData final : GlobalTableFunctionState {
@@ -368,12 +368,12 @@ unique_ptr<FunctionData> c_bind(
     auto& vtab = info.table_function.function_info->Cast<CTableFunctionInfo>().vtab;
     return make_uniq<CTableBindData>(
         make_uniq<CTableFunctionInfo>(vtab),
-        names,
         std::move(session),
-        std::move(data_source));
+        std::move(data_source),
+        names);
 }
 
-const vx_expression* projection(
+const vx_expression* make_projection(
     const vector<column_t>& column_ids,
 	const vector<idx_t>& projection_ids,
     const vector<string>& column_names
@@ -417,6 +417,16 @@ const vx_expression* projection(
     return expr;
 }
 
+const vx_expression* make_filter(
+    optional_ptr<TableFilterSet> table_filters,
+    const vector<column_t>& column_ids,
+    const vector<string>& column_names,
+    const vector<const vx_expression*>& additional_filters,
+    const vx_dtype* dtype
+) {
+    return nullptr;
+}
+
 unique_ptr<GlobalTableFunctionState> c_init_global(ClientContext &, TableFunctionInitInput &input) {
     const auto &bind = input.bind_data->Cast<CTableBindData>();
 
@@ -425,9 +435,16 @@ unique_ptr<GlobalTableFunctionState> c_init_global(ClientContext &, TableFunctio
         .idx_len = 0,
         .include = VX_S_INCLUDE_ALL,
     };
+
+    const vx_dtype* dtype = vx_data_source_dtype(bind.data_source.handle());
+    const vx_expression* projection = make_projection(
+        input.column_ids, input.projection_ids, bind.column_names);
+    const vx_expression* filter = make_filter(input.filters,
+        input.column_ids, bind.column_names, bind.filters, dtype);
+
     vx_scan_options options = {
-        .projection = projection(input.column_ids, input.projection_ids, bind.column_names),
-        .filter = nullptr,
+        .projection = projection,
+        .filter = filter,
         .row_range_begin = 0,
         .row_range_end = 0,
         .selection = selection,
@@ -446,10 +463,10 @@ unique_ptr<LocalTableFunctionState> c_init_local(ExecutionContext &,
 }
 
 void c_function(ClientContext &context, TableFunctionInput &input, DataChunk &output) {
-    Scan& scan = input.global_state->Cast<CTableGlobalData>().scan;
+    auto& global_state = input.global_state->Cast<CTableGlobalData>();
     auto& batch_id = input.local_state->Cast<CTableLocalData>().batch_id;
 
-    auto next_partition = scan.next_partition();
+    auto next_partition = global_state.scan.next_partition();
     if (!next_partition) return;
     Partition partition = std::move(*next_partition);
 
@@ -466,30 +483,17 @@ void c_function(ClientContext &context, TableFunctionInput &input, DataChunk &ou
     }
 }
 
-//void c_pushdown_complex_filter(ClientContext & /*context*/,
-//                               LogicalGet & /*get*/,
-//                               FunctionData *bind_data,
-//                               vector<unique_ptr<Expression>> &filters) {
-//    if (filters.empty()) {
-//        return;
-//    }
-//
-//    auto &bind = bind_data->Cast<CTableBindData>();
-//
-//    for (auto iter = filters.begin(); iter != filters.end();) {
-//        duckdb_vx_error error_out = nullptr;
-//        auto pushed =
-//            bind.info->vtab.pushdown_complex_filter(bind_data->Cast<CTableBindData>().ffi_data->DataPtr(),
-//                                                    reinterpret_cast<duckdb_vx_expr>(iter->get()),
-//                                                    &error_out);
-//        if (error_out) {
-//            throw BinderException(IntoErrString(error_out));
-//        }
-//
-//        // If the pushdown complex filter returns true, we can remove the filter from the list.
-//        iter = pushed ? filters.erase(iter) : std::next(iter);
-//    }
-//}
+const vx_expression* from_filter(const Expression& filter) {
+    return nullptr;
+}
+
+void c_pushdown_complex_filter(ClientContext &, LogicalGet &, FunctionData *bind_data, vector<unique_ptr<Expression>> &filters) {
+    auto &bind = bind_data->Cast<CTableBindData>();
+    // We don't erase filters, see Nick's comment in datasource.rs
+    for (auto iter = filters.begin(); iter != filters.end(); ++iter) {
+        bind.filters.emplace_back(from_filter(**iter));
+    }
+}
 
 unique_ptr<NodeStatistics> c_cardinality(ClientContext &, const FunctionData *bind_data) {
     auto stats = make_uniq<NodeStatistics>();
@@ -537,7 +541,7 @@ extern "C" duckdb_state duckdb_vx_tfunc_register(
     auto db = wrapper->database->instance;
     auto tf = TableFunction(vtab->name, {}, c_function, c_bind, c_init_global, c_init_local);
 
-    //tf.pushdown_complex_filter = c_pushdown_complex_filter;
+    tf.pushdown_complex_filter = c_pushdown_complex_filter;
 
     //tf.projection_pushdown = vtab->projection_pushdown;
     //tf.filter_pushdown = vtab->filter_pushdown;