glaredb_core 25.6.3

Core functionality for GlareDB
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70

use glaredb_error::{Result, not_implemented};
use glaredb_parser::ast;

use super::bind_context::{BindContext, BindScopeRef};
use crate::catalog::drop::{DropInfo, DropObject};
use crate::logical::logical_drop::LogicalDrop;
use crate::logical::operator::{LocationRequirement, Node};
use crate::logical::resolver::ResolvedMeta;
use crate::statistics::value::StatisticsValue;

#[derive(Debug)]
pub struct DropBinder {
    pub current: BindScopeRef,
}

impl DropBinder {
    pub fn new(current: BindScopeRef) -> Self {
        DropBinder { current }
    }

    pub fn bind_drop(
        &self,
        _bind_context: &mut BindContext,
        mut drop: ast::DropStatement<ResolvedMeta>,
    ) -> Result<Node<LogicalDrop>> {
        // Dropping defaults to restricting (erroring) on dependencies.
        let deps = drop.deps.unwrap_or(ast::DropDependents::Restrict);

        match drop.drop_type {
            ast::DropType::Schema => {
                let [catalog, schema] = drop.name.pop_2()?;

                Ok(Node {
                    node: LogicalDrop {
                        catalog,
                        info: DropInfo {
                            schema,
                            object: DropObject::Schema,
                            cascade: ast::DropDependents::Cascade == deps,
                            if_exists: drop.if_exists,
                        },
                    },
                    location: LocationRequirement::ClientLocal,
                    children: Vec::new(),
                    estimated_cardinality: StatisticsValue::Unknown,
                })
            }
            ast::DropType::Table => {
                // Or view
                let [catalog, schema, name] = drop.name.pop_3()?;

                Ok(Node {
                    node: LogicalDrop {
                        catalog,
                        info: DropInfo {
                            schema,
                            object: DropObject::Table(name),
                            cascade: ast::DropDependents::Cascade == deps,
                            if_exists: drop.if_exists,
                        },
                    },
                    location: LocationRequirement::ClientLocal,
                    children: Vec::new(),
                    estimated_cardinality: StatisticsValue::Unknown,
                })
            }
            other => not_implemented!("Drop entry: {other:?}"),
        }
    }
}