/* global print, semver, progress, createCollectionSafe, db, fs, PWD */
// this method will declare all the collection name with proper dbCount
let collection_declaration = (dbCount) =>{
let collection_array = [
`c1_060_${dbCount}`,
`c2_060_${dbCount}`,
`c3_insert_060_${dbCount}`,
`c4_update_060_${dbCount}`,
`c5_replace_060_${dbCount}`,
`c6_not_null_060_${dbCount}`,
`c7_hex_060_${dbCount}`,
`c8_overwriteFalse_060_${dbCount}`,
`c9_overwriteTrue_060_${dbCount}`,
`c10_multiple_060_${dbCount}`,
`c11_060_${dbCount}`,
`c12_060_${dbCount}`
];
return collection_array;
};
// this method will declare all the views name with proper dbCount
let views_name_declaration = (dbCount) =>{
let views_Name_array = [
`test_view_${dbCount}`,
`test_view2_${dbCount}`
];
return views_Name_array;
};
// This method will take db and a tuple parameter containing one query and one
expected output
// as a touple elements and then compare both's results
let result_comparision = (db, tuple) =>{
for (let i = 0; i < tuple.length; i++) {
let query_str = tuple[i][0];
let expected_output = tuple[i][1];
var output = db._query(query_str).toArray();
var newOuput = Number(output);
if (newOuput !== expected_output) {
throw new Error(`${query_str} query_str's output: ${newOuput} didn't match
with ecxpected_output: ${expected_output}`);
//execute queries which use indexes and verify that the proper amount of docs are
returned
function index_array(dbCount){
// get all the collection variable name wtih dbcount
let c = collection_declaration(dbCount);
let index_tuple = [
[`for doc in ${c[0]} OPTIONS { indexHint : 'inverted', forceIndexHint: true,
waitForSync: true } filter doc.cv_field == SOUNDEX('sky') collect with count into c
return c`, 64000],
[`for doc in ${c[0]} OPTIONS { indexHint : 'persistent' } filter doc.cv_field
== SOUNDEX('sky') collect with count into c return c`, 64000],
[`for doc in ${c[1]} OPTIONS { indexHint : 'inverted', forceIndexHint: true,
waitForSync: true } filter doc.cv_field == SOUNDEX('dog') collect with count into c
return c`, 64000],
[`for doc in ${c[1]} OPTIONS { indexHint : 'persistent' } filter doc.cv_field
== SOUNDEX('dog') collect with count into c return c`, 64000],
[`for doc in ${c[2]} OPTIONS { indexHint : 'inverted', forceIndexHint: true,
waitForSync: true } filter doc.cv_field_insert == SOUNDEX('frog') collect with
count into c return c`, 64000],
[`for doc in ${c[2]} OPTIONS { indexHint : 'persistent' } filter
doc.cv_field_insert == SOUNDEX('frog') collect with count into c return c`, 64000],
[`for doc in ${c[3]} OPTIONS { indexHint : 'inverted', forceIndexHint: true,
waitForSync: true } filter doc.cv_field_update == SOUNDEX('beer') collect with
count into c return c`, 0],
[`for doc in ${c[3]} OPTIONS { indexHint : 'persistent' } filter
doc.cv_field_update == SOUNDEX('beer') collect with count into c return c`, 0],
[`for doc in ${c[4]} OPTIONS { indexHint : 'inverted', forceIndexHint: true,
waitForSync: true } filter doc.cv_field_replace == SOUNDEX('water') collect with
count into c return c`, 0],
[`for doc in ${c[4]} OPTIONS { indexHint : 'persistent' } filter
doc.cv_field_replace == SOUNDEX('water') collect with count into c return c`, 0],
[`for doc in ${c[5]} OPTIONS { indexHint : 'inverted', forceIndexHint: true,
waitForSync: true } filter doc.cv_field == not null collect with count into c
return c`, 64000],
[`for doc in ${c[5]} OPTIONS { indexHint : 'persistent' } filter has(doc,
'cv_field') == true collect with count into c return c`, 64000],
[`for doc in ${c[6]} OPTIONS { indexHint : 'inverted', forceIndexHint: true,
waitForSync: true } filter doc.cv_field == TO_HEX(123) collect with count into c
return c`, 11],
[`for doc in ${c[6]} OPTIONS { indexHint : 'persistent' } filter doc.cv_field
== TO_HEX(doc.name) collect with count into c return c`, 64000],
[`for doc in ${c[7]} OPTIONS { indexHint : 'inverted', forceIndexHint: true,
waitForSync: true } filter doc.cv_field == CONCAT('42_', FIRST(for d in ${c[7]}
limit 100, 1 return d.field)) collect with count into c return c`, 17],
[`for doc in ${c[7]} OPTIONS { indexHint : 'persistent' } filter doc.cv_field
== CONCAT('42_', TO_STRING(doc.field)) collect with count into c return c`, 32000],
[`for doc in ${c[8]} OPTIONS { indexHint : 'inverted', forceIndexHint: true,
waitForSync: true } filter doc.cv_field == CONCAT('42_', FIRST(for d in ${c[8]}
limit 101, 1 return d.field)) collect with count into c return c`, 33],
[`for doc in ${c[8]} OPTIONS { indexHint : 'persistent' } filter doc.cv_field
== CONCAT('42_', TO_STRING(doc.field)) collect with count into c return c`, 64000],
[`for doc in ${c[9]} OPTIONS { indexHint : 'persistent' } filter doc.cv_field1
== 'foo' and doc.cv_field2 == 'bar' and doc.cv_field3 == 'baz' collect with count
into c return c`, 64000],
[`for doc in ${c[10]} OPTIONS { indexHint : 'inverted', forceIndexHint: true,
waitForSync: true } filter doc.cv_field == FIRST(for d in ${c[10]} limit 1001, 1
return CONCAT(d._key, ' ', d._id, ' ', d._rev)) collect with count into c return
c`, 1],
[`for doc in ${c[10]} OPTIONS { indexHint : 'persistent' } filter doc.cv_field
== CONCAT(doc._key, ' ', doc._id, ' ', doc._rev) collect with count into c return
c`, 64000]
];
return index_tuple;
// this function will provide all the queries for views
function views_array(dbCount) {
// get all the view's variable name from the variable_name_declaration method
globally
let view = views_name_declaration(dbCount);
let view_tuples = [
[`for doc in ${view[0]} search doc.cv_field == SOUNDEX('sky') collect with
count into c return c`, 64000],
[`for doc in ${view[0]} search doc.cv_field == SOUNDEX('dog') collect with
count into c return c`, 64000],
[`for doc in ${view[0]} search doc.cv_field_insert == SOUNDEX('frog') collect
with count into c return c`, 64000],
[`for doc in ${view[0]} search doc.cv_field_update == SOUNDEX('beer') collect
with count into c return c`, 0],
[`for doc in ${view[0]} search doc.cv_field_replace == SOUNDEX('water') collect
with count into c return c`, 0],
[`for doc in ${view[0]} filter doc.cv_field == to_hex(doc.name) collect with
count into c return c`, 64000],
[`for doc in ${view[0]} filter doc.cv_field == CONCAT('42_',
TO_STRING(doc.field)) collect with count into c return c`, 96000],
[`for doc in ${view[0]} search doc.cv_field1=='foo' and doc.cv_field2=='bar'
and doc.cv_field3=='baz' collect with count into c return c`, 64000],
[`for doc in ${view[0]} filter doc.cv_field == CONCAT(doc._key, ' ', doc._id, '
', doc._rev) collect with count into c return c`, 64000],
[`for doc in ${view[1]} search doc.cv_field == SOUNDEX('sky') collect with
count into c return c`, 64000],
[`for doc in ${view[1]} search doc.cv_field == SOUNDEX('dog') collect with
count into c return c`, 64000],
[`for doc in ${view[1]} search doc.cv_field_insert == SOUNDEX('frog') collect
with count into c return c`, 64000],
[`for doc in ${view[1]} search doc.cv_field_update == SOUNDEX('beer') collect
with count into c return c`, 0],
[`for doc in ${view[1]} search doc.cv_field_replace == SOUNDEX('water') collect
with count into c return c`, 0],
[`for doc in ${view[1]} search doc.cv_field == not null collect with count into
c return c`, 64000],
[`for doc in ${view[1]} filter doc.cv_field == to_hex(doc.name) collect with
count into c return c`, 64000],
[`for doc in ${view[1]} filter doc.cv_field == CONCAT('42_',
TO_STRING(doc.field)) collect with count into c return c`, 96000],
[`for doc in ${view[1]} search doc.cv_field1=='foo' and doc.cv_field2=='bar'
and doc.cv_field3=='baz' collect with count into c return c`, 64000],
[`for doc in ${view[1]} filter doc.cv_field == CONCAT(doc._key, ' ', doc._id, '
', doc._rev) collect with count into c return c`, 64000]
return view_tuples;
(function () {
const a = require("@arangodb/analyzers");
return {
isSupported: function (currentVersion, oldVersion, options, enterprise,
cluster) {
let oldVersionSemver = semver.parse(semver.coerce(oldVersion));
return semver.gte(oldVersionSemver, "3.10.0");
},
makeDataDB: function (options, isCluster, isEnterprise, database, dbCount) {
// All items created must contain dbCount
print(`060: making per database data ${dbCount}`);
print("060: Creating computed values with sample collections");
// getting all the collection names
let c = collection_declaration(dbCount);
let c1 = createCollectionSafe(c[0], 3, 3, { computedValues: [{ "name":
"default", "expression": "RETURN SOUNDEX('sky')", overwrite: true }] });
let c2 = createCollectionSafe(c[1], 3, 3, { computedValues: [{ "name":
"default", "expression": "RETURN SOUNDEX('dog')", overwrite: true }] });
let c3 = createCollectionSafe(c[2], 3, 3, { computedValues: [{ "name":
"default_insert", "expression": "RETURN SOUNDEX('frog')", computeOn: ["insert"],
overwrite: true }] });
let c4 = createCollectionSafe(c[3], 3, 3, { computedValues: [{ "name":
"default_update", "expression": "RETURN SOUNDEX('beer')", computeOn: ["update"],
overwrite: true }] });
let c5 = createCollectionSafe(c[4], 3, 3, { computedValues: [{ "name":
"default_replace", "expression": "RETURN SOUNDEX('water')", computeOn: ["replace"],
overwrite: true }] });
let c6 = createCollectionSafe(c[5], 3, 3, { computedValues: [{ "name":
"default", "expression": "RETURN null", overwrite: true, keepNull: false }] });
let c7 = createCollectionSafe(c[6], 3, 3, { computedValues: [{ "name":
"default", "expression": "RETURN TO_HEX(@doc.name)", overwrite: true }] });
let c8 = createCollectionSafe(c[7], 3, 3, { computedValues: [{ "name":
"default", "expression": "RETURN CONCAT('42_', TO_STRING(@doc.field))", overwrite:
false }] });
let c9 = createCollectionSafe(c[8], 3, 3, { computedValues: [{ "name":
"default", "expression": "RETURN CONCAT('42_', TO_STRING(@doc.field))", overwrite:
true }] });
let c10 = createCollectionSafe(c[9], 3, 3, { computedValues: [{ "name":
"default1", "expression": "RETURN 'foo'", overwrite: true }, { "name": "default2",
"expression": "RETURN 'bar'", overwrite: true }, { "name": "default3",
"expression": "RETURN 'baz'", overwrite: true }] });
let c11 = createCollectionSafe(c[10], 3, 3, { computedValues: [{ "name":
"default", "expression": "RETURN CONCAT(@doc._key, ' ', @doc._id, ' ', @doc._rev)",
overwrite: true }] });
let c12 = createCollectionSafe(c[11], 3, 3, { computedValues: [{ "name":
"default", "expression": "RETURN [{from_doc: CONCAT(@doc.name, ' ', @doc.field),
system:{_key: @doc._key, _rev: @doc._rev, _id: @doc._id}, values: [RANGE(1,
10)]}]", overwrite: true }] });
//-------------------------------------------------------
x-------------------------------------------------------------
// this function will check Computed Values properties
function checkComValProperties(comValueName, obj1, obj2) {
if (obj1.hasOwnProperty('optimizeTopK')) {
delete obj1.optimizeTopK;
if (obj2.hasOwnProperty('optimizeTopK')) {
delete obj2.optimizeTopK;
if(_.isEqual(obj1, obj2) === false){
throw new Error(`Properties missmatched for the collection $
{comValueName} ${JSON.stringify(obj1)} <-> ${JSON.stringify(obj2)}`);
print("060: Perform modification and comparision for desired output of
Computed Values");
//for c1 comVal
let c1_exp_modification = [
name: 'cv_field',
expression: "RETURN SOUNDEX('sky')",
computeOn: [ 'insert', 'update', 'replace' ],
overwrite: true,
failOnWarning: false,
keepNull: true
];
let c1_actual_modification = c1.properties({ computedValues: [{ "name":
"cv_field", "expression": "RETURN SOUNDEX('sky')", overwrite: true }] });
checkComValProperties(c[0], c1_exp_modification,
c1_actual_modification.computedValues);
//for c2 comVal
let c2_exp_modification = [
name: 'cv_field',
expression: "RETURN SOUNDEX('dog')",
computeOn: [ 'insert', 'update', 'replace' ],
overwrite: true,
failOnWarning: false,
keepNull: true
];
let c2_actual_modification = c2.properties({ computedValues: [{ "name":
"cv_field", "expression": "RETURN SOUNDEX('dog')", "overwrite": true }] })
checkComValProperties(c[1], c2_exp_modification,
c2_actual_modification.computedValues);
//for c3_insert comVal
let c3_exp_modification = [
name: 'cv_field_insert',
expression: "RETURN SOUNDEX('frog')",
computeOn: [ 'insert' ],
overwrite: true,
failOnWarning: false,
keepNull: true
];
let c3_actual_modification = c3.properties({ computedValues: [{ "name":
"cv_field_insert", "expression": "RETURN SOUNDEX('frog')", "computeOn": ["insert"],
"overwrite": true }] })
checkComValProperties(c[2], c3_exp_modification,
c3_actual_modification.computedValues);
//for c4_update comVal
let c4_exp_modification = [
name: 'cv_field_update',
expression: "RETURN SOUNDEX('beer')",
computeOn: [ 'update' ],
overwrite: true,
failOnWarning: false,
keepNull: true
];
let c4_actual_modification = c4.properties({ computedValues: [{ "name":
"cv_field_update", "expression": "RETURN SOUNDEX('beer')", "computeOn": ["update"],
"overwrite": true }] });
checkComValProperties(c[3], c4_exp_modification,
c4_actual_modification.computedValues);
//for c5_replace comVal
let c5_exp_modification = [
{
name: 'cv_field_replace',
expression: "RETURN SOUNDEX('water')",
computeOn: [ 'replace' ],
overwrite: true,
failOnWarning: false,
keepNull: true
];
let c5_actual_modification = c5.properties({ computedValues: [{ "name":
"cv_field_replace", "expression": "RETURN SOUNDEX('water')", "computeOn":
["replace"], "overwrite": true }] })
checkComValProperties(c[4], c5_exp_modification,
c5_actual_modification.computedValues);
//for c6_not_null comVal
let c6_exp_modification = [
name: 'cv_field',
expression: 'RETURN not null',
computeOn: [ 'insert', 'update', 'replace' ],
overwrite: true,
failOnWarning: false,
keepNull: false
];
let c6_actual_modification = c6.properties({ computedValues: [{ "name":
"cv_field", "expression": "RETURN not null", "overwrite": true, "keepNull":
false }] });
checkComValProperties(c[5], c6_exp_modification,
c6_actual_modification.computedValues);
//for c7_hex comVal
let c7_exp_modification = [
name: 'cv_field',
expression: 'RETURN TO_HEX(@doc.name)',
computeOn: [ 'insert', 'update', 'replace' ],
overwrite: true,
failOnWarning: false,
keepNull: true
];
let c7_actual_modification = c7.properties({ computedValues: [{ "name":
"cv_field", "expression": "RETURN TO_HEX(@doc.name)", "overwrite": true }] });
checkComValProperties(c[6], c7_exp_modification,
c7_actual_modification.computedValues);
//for c8_overwriteFalse comVal
let c8_exp_modification = [
name: 'cv_field',
expression: "RETURN CONCAT('42_', TO_STRING(@doc.field))",
computeOn: [ 'insert', 'update', 'replace' ],
overwrite: false,
failOnWarning: false,
keepNull: true
}
];
let c8_actual_modification = c8.properties({ computedValues: [{ "name":
"cv_field", "expression": "RETURN CONCAT('42_', TO_STRING(@doc.field))",
"overwrite": false }] });
checkComValProperties(c[7], c8_exp_modification,
c8_actual_modification.computedValues);
//for c9_overwriteTrue comVal
let c9_exp_modification = [
name: 'cv_field',
expression: "RETURN CONCAT('42_', TO_STRING(@doc.field))",
computeOn: [ 'insert', 'update', 'replace' ],
overwrite: true,
failOnWarning: false,
keepNull: true
];
let c9_actual_modification = c9.properties({ computedValues: [{ "name":
"cv_field", "expression": "RETURN CONCAT('42_', TO_STRING(@doc.field))",
"overwrite": true }] });
checkComValProperties(c[8], c9_exp_modification,
c9_actual_modification.computedValues);
//for c10_multiple comVal
let c10_exp_modification = [
name: 'cv_field1',
expression: "RETURN 'foo'",
computeOn: [ 'insert', 'update', 'replace' ],
overwrite: true,
failOnWarning: false,
keepNull: true
},
name: 'cv_field2',
expression: "RETURN 'bar'",
computeOn: [ 'insert', 'update', 'replace' ],
overwrite: true,
failOnWarning: false,
keepNull: true
},
name: 'cv_field3',
expression: "RETURN 'baz'",
computeOn: [ 'insert', 'update', 'replace' ],
overwrite: true,
failOnWarning: false,
keepNull: true
];
let c10_actual_modification = c10.properties({ computedValues: [{ "name":
"cv_field1", "expression": "RETURN 'foo'", "overwrite": true }, { "name":
"cv_field2", "expression": "RETURN 'bar'", "overwrite": true }, { "name":
"cv_field3", "expression": "RETURN 'baz'", "overwrite": true }] })
checkComValProperties(c[9], c10_exp_modification,
c10_actual_modification.computedValues);
//for c11 comVal
let c11_exp_modification = [
name: 'cv_field',
expression: "RETURN CONCAT(@doc._key, ' ', @doc._id, ' ', @doc._rev)",
computeOn: [ 'insert', 'update', 'replace' ],
overwrite: true,
failOnWarning: false,
keepNull: true
];
let c11_actual_modification = c11.properties({ computedValues: [{ "name":
"cv_field", "expression": "RETURN CONCAT(@doc._key, ' ', @doc._id, ' ',
@doc._rev)", "overwrite": true }] });
checkComValProperties(c[10], c11_exp_modification,
c11_actual_modification.computedValues);
//for c12_overwriteTrue comVal
let c12_exp_modification = [
name: 'cv_field',
expression: "RETURN [{from_doc: CONCAT(@doc.name, ' ', @doc.field),
system:{_key: @doc._key, _rev: @doc._rev, _id: @doc._id}, values: [RANGE(1,
10)]}]",
computeOn: [ 'insert', 'update', 'replace' ],
overwrite: true,
failOnWarning: false,
keepNull: true
}
];
let c12_actual_modification = c12.properties({ computedValues: [{ "name":
"cv_field", "expression": "RETURN [{from_doc: CONCAT(@doc.name, ' ', @doc.field),
system:{_key: @doc._key, _rev: @doc._rev, _id: @doc._id}, values: [RANGE(1,
10)]}]", "overwrite": true }] });
checkComValProperties(c[11], c12_exp_modification,
c12_actual_modification.computedValues);
//-------------------------------------------------------
x-------------------------------------------------------------
c1.ensureIndex({"type":"inverted","name":"inverted","fields":
[{"name":"cv_field"}]});
c1.ensureIndex({"type":"persistent","name":"persistent","fields":
["cv_field"], "sparse": true});
c2.ensureIndex({"type":"inverted","name":"inverted","fields":
[{"name":"cv_field"}]});
c2.ensureIndex({"type":"persistent","name":"persistent","fields":
["cv_field"], "sparse": true});
c3.ensureIndex({"type":"inverted","name":"inverted","fields":[{"name":
"cv_field_insert"}]});
c3.ensureIndex({"type":"persistent","name":"persistent","fields":
["cv_field_insert"], "sparse": true});
c4.ensureIndex({"type":"inverted","name":"inverted","fields":
[{"name":"cv_field_update"}]});
c4.ensureIndex({"type":"persistent","name":"persistent","fields":
["cv_field_update"], "sparse": true});
c5.ensureIndex({"type":"inverted","name":"inverted","fields":
[{"name":"cv_field_replace"}]});
c5.ensureIndex({"type":"persistent","name":"persistent","fields":
["cv_field_replace"], "sparse": true});
c6.ensureIndex({"type":"inverted","name":"inverted","fields":
[{"name":"cv_field"}]});
c6.ensureIndex({"type":"persistent","name":"persistent","fields":
["cv_field"], "sparse": true});
c7.ensureIndex({"type":"inverted","name":"inverted","fields":
[{"name":"cv_field"}]});
c7.ensureIndex({"type":"persistent","name":"persistent","fields":
["cv_field"], "sparse": true});
c8.ensureIndex({"type":"inverted","name":"inverted","fields":
[{"name":"cv_field"}]});
c8.ensureIndex({"type":"persistent","name":"persistent","fields":
["cv_field"], "sparse": true});
c9.ensureIndex({"type":"inverted","name":"inverted","fields":
[{"name":"cv_field"}]});
c9.ensureIndex({"type":"persistent","name":"persistent","fields":
["cv_field"], "sparse": true});
c10.ensureIndex({"type":"inverted","name":"inverted","fields":
[{"name":"cv_field1"},{"name":"cv_field2"},{"name":"cv_field3"}]});
c10.ensureIndex({"type":"persistent","name":"persistent","fields":
["cv_field1", "cv_field2", "cv_field3"], "sparse": true});
c11.ensureIndex({"type":"inverted","name":"inverted","fields":
[{"name":"cv_field"}]});
c11.ensureIndex({"type":"persistent","name":"persistent","fields":
["cv_field"], "sparse": true});
c12.ensureIndex({"type":"inverted","name":"inverted","fields":
[{"name":"cv_field", "nested": ["from_doc"]}]});
//-------------------------------------------------------
x-------------------------------------------------------------
// creating views for the collections
print("060: Creating computed values views with sample collections");
// get all the view's variable name from the variable_name_declaration method
globally
let view = views_name_declaration(dbCount);
db._createView(view[0], "arangosearch");
let creationOutput = db[view[0]].properties(
{"links":{
[[c[0]]]:{"fields": {"cv_field": {}},"includeAllFields":true},
[[c[1]]]:{"fields": {"cv_field": {}},"includeAllFields":true},
[[c[2]]]:{"fields": {"cv_field": {}},"includeAllFields":true},
[[c[3]]]:{"fields": {"cv_field": {}},"includeAllFields":true},
[[c[4]]]:{"fields": {"cv_field": {}},"includeAllFields":true},
[[c[5]]]:{"fields": {"cv_field": {}},"includeAllFields":true},
[[c[6]]]:{"fields": {"cv_field": {}},"includeAllFields":true},
[[c[7]]]:{"fields": {"cv_field": {}},"includeAllFields":true},
[[c[8]]]:{"fields": {"cv_field": {}},"includeAllFields":true},
[[c[9]]]:{"fields": {"cv_field": {}},"includeAllFields":true},
[[c[10]]]:{"fields": {"cv_field": {}},"includeAllFields":true},
[[c[11]]]:{"fields": {"cv_field": {}},"includeAllFields":true}
});
let expected_output = {
"cleanupIntervalStep" : 2,
"commitIntervalMsec" : 1000,
"consolidationIntervalMsec" : 1000,
"consolidationPolicy" : {
"type" : "tier",
"segmentsBytesFloor" : 2097152,
"segmentsBytesMax" : 5368709120,
"segmentsMax" : 10,
"segmentsMin" : 1,
"minScore" : 0
},
"primarySort" : [ ],
"primarySortCompression" : "lz4",
"storedValues" : [ ],
"writebufferActive" : 0,
"writebufferIdle" : 64,
"writebufferSizeMax" : 33554432,
"links" : {
[c[0]] : {
"analyzers" : [
"identity"
],
"fields" : {
"cv_field" : {
},
"includeAllFields" : true,
"storeValues" : "none",
"trackListPositions" : false
},
[c[1]] : {
"analyzers" : [
"identity"
],
"fields" : {
"cv_field" : {
},
"includeAllFields" : true,
"storeValues" : "none",
"trackListPositions" : false
},
[c[2]] : {
"analyzers" : [
"identity"
],
"fields" : {
"cv_field" : {
},
"includeAllFields" : true,
"storeValues" : "none",
"trackListPositions" : false
},
[c[3]] : {
"analyzers" : [
"identity"
],
"fields" : {
"cv_field" : {
},
"includeAllFields" : true,
"storeValues" : "none",
"trackListPositions" : false
},
[c[4]] : {
"analyzers" : [
"identity"
],
"fields" : {
"cv_field" : {
},
"includeAllFields" : true,
"storeValues" : "none",
"trackListPositions" : false
},
[c[5]] : {
"analyzers" : [
"identity"
],
"fields" : {
"cv_field" : {
},
"includeAllFields" : true,
"storeValues" : "none",
"trackListPositions" : false
},
[c[6]] : {
"analyzers" : [
"identity"
],
"fields" : {
"cv_field" : {
},
"includeAllFields" : true,
"storeValues" : "none",
"trackListPositions" : false
},
[c[7]] : {
"analyzers" : [
"identity"
],
"fields" : {
"cv_field" : {
},
"includeAllFields" : true,
"storeValues" : "none",
"trackListPositions" : false
},
[c[8]] : {
"analyzers" : [
"identity"
],
"fields" : {
"cv_field" : {
},
"includeAllFields" : true,
"storeValues" : "none",
"trackListPositions" : false
},
[c[9]] : {
"analyzers" : [
"identity"
],
"fields" : {
"cv_field" : {
},
"includeAllFields" : true,
"storeValues" : "none",
"trackListPositions" : false
},
[c[10]] : {
"analyzers" : [
"identity"
],
"fields" : {
"cv_field" : {
},
"includeAllFields" : true,
"storeValues" : "none",
"trackListPositions" : false
},
[c[11]] : {
"analyzers" : [
"identity"
],
"fields" : {
"cv_field" : {
},
"includeAllFields" : true,
"storeValues" : "none",
"trackListPositions" : false
// this method will compare two outputs
checkComValProperties(`${view[0]}`, creationOutput, expected_output);
// creating testviewV2 allias
db._createView(view[1], "search-alias", {
"indexes": [
'collection': c[0],
'index': 'inverted'
},
'collection': c[1],
'index': 'inverted'
},
'collection': c[2],
'index': 'inverted'
},
'collection': c[3],
'index': 'inverted'
},
'collection': c[4],
'index': 'inverted'
},
'collection': c[5],
'index': 'inverted'
},
'collection': c[6],
'index': 'inverted'
},
'collection': c[7],
'index': 'inverted'
},
'collection': c[8],
'index': 'inverted'
},
'collection': c[9],
'index': 'inverted'
},
'collection': c[10],
'index': 'inverted'
},
'collection': c[11],
'index': 'inverted'
})
//-------------------------------------------------------
x-------------------------------------------------------------
//inserting data to all collection
let data_array = [c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12];
let docsAsStr = fs.read(`${PWD}/makedata_suites/060_computed_value.json`);
// this function will read and insert and check all the neccessary data for
the respective collection
data_array.forEach(col => {
col.save(JSON.parse(docsAsStr), { silent: true });
//this cmd will find one docs from the collection
let has_cv_field = col.all().toArray();
// checking computed value field exit on the collection's doc
const field_name = (col === c3) ? "cv_field_insert" : "cv_field";
if (!has_cv_field.some(obj => obj.hasOwnProperty(field_name))) {
throw new Error(`060: Computed value field '${field_name}' missing from
collection ${col.name}`);
}else{
print(`success for ${col.name}`)
});
//execute queries which use views and verify that the proper amount of docs
are returned
let index_tuple = index_array(dbCount);
result_comparision(db, index_tuple);
//execute queries which use views and verify that the proper amount of docs
are returned
let viewTuple = views_array(dbCount);
result_comparision(db, viewTuple);
return 0;
},
checkDataDB: function (options, isCluster, isEnterprise, database, dbCount,
readOnly) {
print(`060: checking data ${dbCount}`);
//execute queries which use views and verify that the proper amount of docs
are returned
let index_tuple = index_array(dbCount);
result_comparision(db, index_tuple);
//execute queries which use views and verify that the proper amount of docs
are returned
let viewTuple = views_array(dbCount);
result_comparision(db, viewTuple);
return 0;
},
clearDataDB: function (options, isCluster, isEnterprise, database, dbCount) {
print(`060: clearing data ${dbCount}`);
// get all the view's variable name from the variable_name_declaration method
globally
let view = views_name_declaration(dbCount);
try {
db._dropView(`${view[0]}`);
db._dropView(`${view[1]}`);
} catch (error) {
console.log('060: Deleting view failed with :', error.message);
throw error;
progress("060: deleted views");
// getting all the collection name with dbcount
let c = collection_declaration(dbCount);
c.forEach(col => {
db[col].properties({computedValues: []})
//checking the properties set to null properly
if (db[col].properties()["computedValues"] == null) {
//drop the collection after check
db._drop(col);
progress(`060: deleting ${col} collection`);
} else {
throw new Error(`060: ${col} deletion failed!`);
})
return 0;
};
}());
