qm.Store

//import qm module
var qm = require('qminer');
// create a new base containing one store
var base = new qm.Base({
   mode: "createClean",
   schema: [{
       name: "Festivals",
       fields: [
           { name: "Name", type: "string" },
           { name: "Type", type: "string" },
           { name: "Location", type: "string" }
       ]
   }]
});
// add some records in the store
base.store("Festivals").push({ Name: "Metaldays", Type: "music", Location: "Tolmin, Slovenia" });
base.store("Festivals").push({ Name: "Festival de Cannes", Type: "movie", Location: "Cannes, France" });
base.store("Festivals").push({ Name: "The Festival of Chocolate", Type: "food", Location: "Hillsborough, USA" });
// get the field value of the second record for field "Type"
var fieldValue = base.store("Festivals").cell(1, "Type"); // returns "movie"
base.close();

// import qm module
var qm = require('qminer');
// create a base containing one store
var base = new qm.Base({
   mode: "createClean",
   schema: [{
       name: "TVSeries",
       fields: [
           { name: "Title", type: "string", primary: true },
           { name: "NumberOfEpisodes", type: "int" }
       ]
   }]
});
// add some records in the store
base.store("TVSeries").push({ Title: "Archer", NumberOfEpisodes: 75 });
base.store("TVSeries").push({ Title: "The Simpsons", NumberOfEpisodes: 574 });
base.store("TVSeries").push({ Title: "New Girl", NumberOfEpisodes: 94 });
base.store("TVSeries").push({ Title: "Rick and Morty", NumberOfEpisodes: 11 });
base.store("TVSeries").push({ Title: "Game of Thrones", NumberOfEpisodes: 47 });
// deletes the first 2 records (Archer and The Simpsons) in TVSeries
base.store("TVSeries").clear(2); // returns 3
// delete all remaining records in TVStore
base.store("TVSeries").clear();  // returns 0
base.close();

// import qm module
var qm = require('qminer');
// create a base containing the store Class
var base = new qm.Base({
   mode: "createClean",
   schema: [{
       name: "Class",
       fields: [
           { name: "Name", type: "string" },
           { name: "StudyGroup", type: "string" }
       ]
   }]
});
// add some records to the store
base.store("Class").push({ Name: "Abed", StudyGroup: "A" });
base.store("Class").push({ Name: "Annie", StudyGroup: "B" });
base.store("Class").push({ Name: "Britta", StudyGroup: "C" });
base.store("Class").push({ Name: "Jeff", StudyGroup: "A" });
// change the StudyGroup of all records of store Class to A
base.store("Class").each(function (rec) { rec.StudyGroup = "A"; });   // all records in Class are now in study group A
base.close();

// import qm module
var qm = require("qminer");
// create a new base containing one store
var base = new qm.Base({
   mode: "createClean",
   schema: [{
       name: "People",
       fields: [
           { name: "Name", type: "string", primary: true },
           { name: "Gender", type: "string" },
           { name: "Age", type: "int" }
       ]
   }]
});
// get the details of the field "Name" of store "People"
// it returns a JSON object:
// { id: 0, name: "Name", type: "string", primary: true, nullable: false, internal: false }
var details = base.store("People").field("Name");
base.close();

// import qm module
var qm = require('qminer');
// create a new base containing one store
var base = new qm.Base({
   mode: "createClean",
   schema: [{
       name: "ArcheryChampionship",
       fields: [
           { name: "Name", type: "string" },
           { name: "ScorePerRound", type: "float_v" }
       ]
   }]
});
// set new records in the store
base.store("ArcheryChampionship").push({ Name: "Robin Hood", ScorePerRound: [50, 48, 48] });
base.store("ArcheryChampionship").push({ Name: "Oliver Queen", ScorePerRound: [44, 46, 44] });
base.store("ArcheryChampionship").push({ Name: "Legolas", ScorePerRound: [50, 50, 48] });
// get the matrix containing the "score per round" values
// The values of the i-th column are the values of the i-th record.
// The function will give the matrix:
// 50  44  50
// 48  46  50
// 48  44  48
var matrix = base.store("ArcheryChampionship").getMatrix("ScorePerRound");
base.close();

// import qm module
var qm = require('qminer');
// create a simple base containing one store
var base = new qm.Base({
   mode: "createClean",
   schema: [{
       name: "Laser",
       fields: [
           { name: "Time", type: "datetime" },
           { name: "WaveLength", type: "float" }
       ]
   }]
});

// create a new time series window buffer stream aggregator for 'Laser' store (with the JSON object)
var wavelength = {
    name: "WaveLengthLaser",
    type: "timeSeriesWinBuf",
    store: "Laser",
    timestamp: "Time",
    value: "WaveLength",
    winsize: 10000
}
var sa = base.store("Laser").addStreamAggr(wavelength);
// get the stream aggregates on store "Laser"
base.store("Laser").getStreamAggrNames();
base.close();

// import qm module
var qm = require('qminer');
// create a base containing one store
var base = new qm.Base({
   mode: "createClean",
   schema: [{
       name: "Companies",
       fields: [
           { name: "Name", type: "string", primary: true },
           { name: "Location", type: "string" }
       ]
   }]
});
// add some records to the store
base.store("Companies").push({ Name: "DC Comics", Location: "Burbank, California" });
base.store("Companies").push({ Name: "DC Shoes", Location: "Huntington Beach, California" });
base.store("Companies").push({ Name: "21st Century Fox", Location: "New York City, New York" });
// get the vector of company names
var companyNames = base.store("Companies").getVector("Name"); // returns a vector ["DC Comics", "DC Shoes", "21st Century Fox"]
base.close();

// import qm module
var qm = require('qminer');
// create a new base containing one store
var base = new qm.Base({
   mode: "createClean",
   schema: [{
       name: "BasketballPlayers",
       fields: [
           { name: "Name", type: "string" },
           { name: "SeasonScore", type: "int_v" },
           { name: "DateOfBirth", type: "datetime" }
       ]
   }]
});
// check if the SeasonScore field is of type Date
var isSeasonScoreDate = base.store("BasketballPlayers").isDate("SeasonScore"); // returns false
// check if the FirstPlayed field is of type Date
var isFirstPlayedDate = base.store("BasketballPlayers").isDate("DateOfBirth"); // returns true
base.close();

// import qm module
var qm = require('qminer');
// create a base containing one store
var base = new qm.Base({
   mode: "createClean",
   schema: [{
       name: "TVSeries",
       fields: [
           { name: "Title", type: "string", primary: true },
           { name: "NumberOfEpisodes", type: "int" }
       ]
   }]
});
// check if the field "Title" is of numeric type
var isTitleNumeric = base.store("TVSeries").isNumeric("Title"); // returns false
// check if the field "NumberOfEpisodes" is of numeric type
var isNumberOfEpisodesNumeric = base.store("TVSeries").isNumeric("NumberOfEpisodes"); // returns true
base.close();

// import qm module
var qm = require("qminer");
// create a new base containing one store
var base = new qm.Base({
   mode: "createClean",
   schema: [{
       name: "People",
       fields: [
           { name: "Name", type: "string", primary: true },
           { name: "Gender", type: "string" },
           { name: "Age", type: "int" }
       ]
   }]
});
// check if the field "Name" is of string type
var isNameString = base.store("People").isString("Name"); // returns true
// check if the field "Age" is of string type
var isAgeString = base.store("People").isString("Age"); // returns false
base.close();

// import qm module
var qm = require('qminer');
// create a new base containing one store
var base = new qm.Base({
   mode: "createClean",
   schema: [{
       name: "Countries",
       fields: [
           { name: "Name", type: "string", primary: true },
           { name: "Population", type: "int" },
           { name: "Continent", type: "string" }
       ],
       keys: [
           { field: "Name", type: "text" },
           { field: "Continent", type: "value" }
       ]
   }]
});
// get the details of the key of the field "Continent"
// returns a JSON object containing the details of the key:
// { fq: { length: 0 }, vocabulary: { length: 0 }, name: 'Continent', store: { name: 'Countries', ... }}
var details = base.store("Countries").key("Continent");
base.close();

// import qm module
var qm = require('qminer');
// create a base containing the store Class
var base = new qm.Base({
   mode: "createClean",
   schema: [{
       name: "Class",
       fields: [
           { name: "Name", type: "string" },
           { name: "StudyGroup", type: "string" }
       ]
   }]
});
// add some records to the store
base.store("Class").push({ Name: "Shirley", StudyGroup: "A" });
base.store("Class").push({ Name: "Troy", StudyGroup: "B" });
base.store("Class").push({ Name: "Chang", StudyGroup: "C" });
base.store("Class").push({ Name: "Pierce", StudyGroup: "A" });
// make an array of record names
var arr = base.store("Class").map(function (rec) { return rec.Name; }); // returns an array ["Shirley", "Troy", "Chang", "Pierce"]
base.close();

// import qm module
var qm = require('qminer');
// create a new base containing one store
var base = new qm.Base({
   mode: "createClean",
   schema: [{
       name: "Planets",
       fields: [
           { name: "Name", type: "string" },
           { name: "Diameter", type: "int" },
           { name: "NearestStars", type: "string_v" }
       ]
   }]
});
// add a new planet in the store
base.store("Planets").push({ Name: "Earth", Diameter: 299196522, NearestStars: ["Sun"] });
// create a record of a planet (not added to the Planets store)
var planet = base.store("Planets").newRecord({ Name: "Tatooine", Diameter: 10465, NearestStars: ["Tatoo 1", "Tatoo 2"] });
base.close();

// import qm module
var qm = require('qminer');
// create a new base containing one store
var base = new qm.Base({
   mode: "createClean",
   schema: [{
       name: "Superheroes",
       fields: [
           { name: "Name", type: "string" },
           { name: "Superpowers", type: "string_v" }
       ]
   }]
});
// add some new records to the store
base.store("Superheroes").push({ Name: "Superman", Superpowers: ["Superhuman strength, speed, hearing", "Flight", "Heat vision"] });
base.store("Superheroes").push({ Name: "Batman", Superpowers: ["Genius-level intellect", "Peak physical and mental conditioning", "Master detective"] });
base.store("Superheroes").push({ Name: "Thor", Superpowers: ["Superhuman strength, endurance and longevity", "Abilities via Mjolnir"] });
base.store("Superheroes").push({ Name: "Wonder Woman", Superpowers: ["Superhuman strength, agility and endurance", "Flight", "Highly skilled hand-to-hand combatant"] });
// create a new record set containing only the DC Comic superheroes (those with the record ids 0, 1 and 3)
var intVec = new qm.la.IntVector([0, 1, 3]);
var DCHeroes = base.store("Superheroes").newRecordSet(intVec);
base.close();

// import qm module
var qm = require('qminer');
// create a new base containing two stores
var base = new qm.Base({
   mode: "createClean",
   schema: [
   {
       name: "Superheroes",
       fields: [
           { name: "Name", type: "string" },
           { name: "Superpowers", type: "string_v" }
       ]
   },
   {
       name: "Supervillians",
       fields: [
           { name: "Name", type: "string" },
           { name: "Superpowers", type: "string_v" }
       ]
   }]
});
// add a new superhero to the Superheroes store
base.store("Superheroes").push({ Name: "Superman", Superpowers: ["flight", "heat vision", "bulletproof"] }); // returns 0
// add a new supervillian to the Supervillians store
base.store("Supervillians").push({ Name: "Lex Luthor", Superpowers: ["expert engineer", "genius-level intellect", "money"] }); // returns 0
base.close();

// import qm module
var qm = require('qminer');
// create a base containing the store Class. Let the Name field be the primary field.
var base = new qm.Base({
   mode: "createClean",
   schema: [{
       name: "Class",
       fields: [
           { name: "Name", type: "string", primary: true },
           { name: "StudyGroup", type: "string" }
       ]
   }]
});
// add some records to the store
base.store("Class").push({ Name: "Dean", StudyGroup: "A" });
base.store("Class").push({ Name: "Chang", StudyGroup: "D" });
base.store("Class").push({ Name: "Magnitude", StudyGroup: "C" });
base.store("Class").push({ Name: "Leonard", StudyGroup: "B" });
// get the record with the name "Magnitude"
var record = base.store("Class").recordByName("Magnitude");
base.close();

// import qm module
var qm = require('qminer');
// create a simple base containing one store
var base = new qm.Base({
   mode: "createClean",
   schema: [{
       name: "Laser",
       fields: [
           { name: "Time", type: "datetime" },
           { name: "WaveLength", type: "float" }
       ]
   }]
});

// create a new time series window buffer stream aggregator for 'Laser' store (with the JSON object)
var wavelength = {
    name: "WaveLengthLaser",
    type: "timeSeriesWinBuf",
    store: "Laser",
    timestamp: "Time",
    value: "WaveLength",
    winsize: 10000
}
var sa = base.store("Laser").addStreamAggr(wavelength);
// reset the stream aggregates on store "Laser"
base.store("Laser").resetStreamAggregates();
base.close();

// import qm module
var qm = require('qminer');
// create a base containing one store
var base = new qm.Base({
   mode: "createClean",
   schema: [{
       name: "TVSeries",
       fields: [
           { name: "Title", type: "string", primary: true },
           { name: "NumberOfEpisodes", type: "int" }
       ]
   }]
});
// add some records in the store
base.store("TVSeries").push({ Title: "Archer", NumberOfEpisodes: 75 });
base.store("TVSeries").push({ Title: "The Simpsons", NumberOfEpisodes: 574 });
base.store("TVSeries").push({ Title: "New Girl", NumberOfEpisodes: 94 });
base.store("TVSeries").push({ Title: "Rick and Morty", NumberOfEpisodes: 11 });
base.store("TVSeries").push({ Title: "Game of Thrones", NumberOfEpisodes: 47 });
// create a sample record set containing 3 records
var randomRecordSet = base.store("TVSeries").sample(3); // contains 3 random records from the TVSeries store
base.close();

// import qm module
var qm = require('qminer');
// create a new base containing one store
var base = new qm.Base({
   mode: "createClean",
   schema: [{
       name: "FootballPlayers",
       fields: [
           { name: "Name", type: "string" },
           { name: "FootballClubs", type: "string_v" },
           { name: "GoalsPerSeason", type: "int_v" },
       ]
   }]
});
// get the store as a JSON object
// the returned JSON object is:
// { storeId: 0, storeName: 'FootballPlayers', storeRecords: 0, fields: [...], keys: [], joins: [] }
var json = base.store("FootballPlayers").toJSON();
base.close();