relay-knowledge 1.1.9

Graph-database-based knowledge graph project.
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
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140

use rusqlite::{Transaction, params};

use crate::storage::StorageError;

use super::super::super::{SearchDocumentInserter, code_search::delete_search_documents_for_kind};

pub(super) fn rebuild_reference_search_documents(
    transaction: &Transaction<'_>,
    source_scope: &str,
) -> Result<(), StorageError> {
    delete_search_documents_for_kind(transaction, source_scope, "reference")?;
    let mut select = transaction.prepare(
        "
        SELECT reference.reference_id, reference.path, coalesce(file.language_id, ''),
               reference.name, reference.kind, coalesce(reference.target_hint, '')
        FROM code_repository_references reference
        LEFT JOIN code_repository_files file
          ON file.source_scope = reference.source_scope
         AND file.path = reference.path
        WHERE reference.source_scope = ?1
        ",
    )?;
    let mut rows = select.query(params![source_scope])?;
    let mut inserter = SearchDocumentInserter::new(transaction)?;
    while let Some(row) = rows.next()? {
        let record_id = row.get::<_, String>(0)?;
        let path = row.get::<_, String>(1)?;
        let language_id = row.get::<_, String>(2)?;
        let name = row.get::<_, String>(3)?;
        let kind = row.get::<_, String>(4)?;
        let target_hint = row.get::<_, String>(5)?;
        inserter.insert(
            source_scope,
            "reference",
            &record_id,
            &path,
            &language_id,
            [
                name.as_str(),
                kind.as_str(),
                target_hint.as_str(),
                path.as_str(),
            ],
        )?;
    }

    Ok(())
}

pub(super) fn rebuild_import_search_documents(
    transaction: &Transaction<'_>,
    source_scope: &str,
) -> Result<(), StorageError> {
    delete_search_documents_for_kind(transaction, source_scope, "import")?;
    let mut select = transaction.prepare(
        "
        SELECT import.import_id, import.path, coalesce(file.language_id, ''),
               import.module, coalesce(import.target_hint, '')
        FROM code_repository_imports import
        LEFT JOIN code_repository_files file
          ON file.source_scope = import.source_scope
         AND file.path = import.path
        WHERE import.source_scope = ?1
        ",
    )?;
    let mut rows = select.query(params![source_scope])?;
    let mut inserter = SearchDocumentInserter::new(transaction)?;
    while let Some(row) = rows.next()? {
        let record_id = row.get::<_, String>(0)?;
        let path = row.get::<_, String>(1)?;
        let language_id = row.get::<_, String>(2)?;
        let module = row.get::<_, String>(3)?;
        let target_hint = row.get::<_, String>(4)?;
        inserter.insert(
            source_scope,
            "import",
            &record_id,
            &path,
            &language_id,
            [module.as_str(), target_hint.as_str(), path.as_str()],
        )?;
    }

    Ok(())
}

pub(super) fn rebuild_call_search_documents(
    transaction: &Transaction<'_>,
    source_scope: &str,
) -> Result<(), StorageError> {
    delete_search_documents_for_kind(transaction, source_scope, "call")?;
    let mut select = transaction.prepare(
        "
        SELECT call.call_id, call.path, coalesce(file.language_id, ''),
               coalesce(call.caller_name, ''), call.callee_name,
               coalesce(call.target_hint, ''), coalesce(caller.signature, ''),
               coalesce(callee.signature, '')
        FROM code_repository_calls call
        LEFT JOIN code_repository_files file
          ON file.source_scope = call.source_scope
         AND file.path = call.path
        LEFT JOIN code_repository_symbols caller
          ON caller.source_scope = call.source_scope
         AND caller.symbol_snapshot_id = call.caller_symbol_snapshot_id
        LEFT JOIN code_repository_symbols callee
          ON callee.source_scope = call.source_scope
         AND callee.symbol_snapshot_id = call.callee_symbol_snapshot_id
        WHERE call.source_scope = ?1
        ",
    )?;
    let mut rows = select.query(params![source_scope])?;
    let mut inserter = SearchDocumentInserter::new(transaction)?;
    while let Some(row) = rows.next()? {
        let record_id = row.get::<_, String>(0)?;
        let path = row.get::<_, String>(1)?;
        let language_id = row.get::<_, String>(2)?;
        let caller_name = row.get::<_, String>(3)?;
        let callee_name = row.get::<_, String>(4)?;
        let target_hint = row.get::<_, String>(5)?;
        let caller_signature = row.get::<_, String>(6)?;
        let callee_signature = row.get::<_, String>(7)?;
        inserter.insert(
            source_scope,
            "call",
            &record_id,
            &path,
            &language_id,
            [
                caller_name.as_str(),
                callee_name.as_str(),
                target_hint.as_str(),
                caller_signature.as_str(),
                callee_signature.as_str(),
                path.as_str(),
            ],
        )?;
    }

    Ok(())
}