FilesExpand file tree

 master

/

plan-builder-base.js

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

103 lines (94 loc) · 3.26 KB

 master

/

plan-builder-base.js

Copy path

Top

File metadata and controls

• Code
• Blame

103 lines (94 loc) · 3.26 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

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

/*

* Copyright (c) 2021 MarkLogic Corporation

*

* 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.

*/

'use strict';

const marklogic = require('../');

const testconfig = require('../etc/test-config');

const dbWriter = marklogic.createDatabaseClient(testconfig.restWriterConnection);

const dbReader = marklogic.createDatabaseClient(testconfig.restReaderConnection);

const planBuilder = marklogic.planBuilder;

const rowMgr = dbReader.rows;

const lit = planBuilder.fromLiterals({rowId:1});

function makeInput(values) {

if (values === void 0) {

return lit;

}

return lit.select(values.map((value, i) => planBuilder.as(String(i + 1), value)));

}

function makeTest(input, expression) {

return input.select(planBuilder.as('t', expression));

}

function execPlan(query, bindings, output) {

const plan = JSON.stringify(query.export());

// console.log(plan);

const rowOutput = (output === void 0 || output === null) ? 'object' : output;

if (bindings === void 0 || bindings === null) {

return rowMgr.query(plan, {format: 'json', structure: rowOutput});

}

return rowMgr.query(plan, {format: 'json', structure: rowOutput, bindings:bindings});

}

function explainPlan(query, format) {

const plan = JSON.stringify(query.export());

return rowMgr.explain(plan, (format === void 0 || format === null) ? 'json' : format);

}

function generateViewPlan(query, schema, view, queryType) {

const plan = JSON.stringify(query.export());

return rowMgr.generateView(plan, schema, view, queryType);

}

function testPlan(values, expression) {

return execPlan(makeTest(makeInput(values), expression));

}

function getResults(response) {

if (response.statusCode >= 500) {

const err = new Error(response.statusCode);

err.response = response;

throw err;

}

if (Array.isArray(response) && response.length > 0 && Array.isArray(response[0].columns)) {

return response.slice(1);

}

const rows = response.rows;

if (rows === void 0) {

return response;

}

return rows;

}

function getResult(response) {

return getResults(response)[0].t;

}

function makeSelectCall(list) {

return lit.select(list);

}

function makeSelectExport(list) {

return {$optic:{ns:'op', fn:'operators', args:[

{ns:'op', fn:'from-literals', args:[[{rowId:1}]]},

{ns:'op', fn:'select', args: Array.isArray(list) ? list : [list] }

]}};

}

module.exports = {

dbReader: dbReader,

dbWriter: dbWriter,

planBuilder: planBuilder,

execPlan: execPlan,

explainPlan: explainPlan,

getResult: getResult,

getResults: getResults,

makeInput: makeInput,

makeSelectCall: makeSelectCall,

makeSelectExport: makeSelectExport,

makeTest: makeTest,

testPlan: testPlan,

generateViewPlan: generateViewPlan

};