class static

qm.RecordSet

// import qm module
var qm = require('qminer');
// create a new base containing one store
var base = new qm.Base({
   mode: "createClean",
   schema: [{
       name: "Philosophers",
       fields: [
           { name: "Name", type: "string" },
           { name: "Era", type: "string" }
       ]
   }]
});
// put some records in the store
base.store("Philosophers").push({ Name: "Plato", Era: "Ancient philosophy" });
base.store("Philosophers").push({ Name: "Immanuel Kant", Era: "18th-century philosophy" });
base.store("Philosophers").push({ Name: "Emmanuel Levinas", Era: "20th-century philosophy" });
base.store("Philosophers").push({ Name: "Rene Descartes", Era: "17th-century philosophy" });
base.store("Philosophers").push({ Name: "Confucius", Era: "Ancient philosophy" });
// create a record set out of the records in store
var recordSet = base.store("Philosophers").allRecords;
// clone the record set of the "Philosophers" store
var philosophers = recordSet.clone();
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: "BookWriters",
       fields: [
           { name: "Name", type: "string" },
           { name: "Genre", type: "string" },
           { name: "Books", type: "string_v" }
       ]
   }]
});
// set new records in the store
base.store("BookWriters").push({ Name: "Terry Pratchett", Genre: "Fantasy", Books: ["The Colour of Magic", "Going Postal", "Mort", "Guards! Guards!"] });
base.store("BookWriters").push({ Name: "Douglas Adams", Genre: "Sci-fi", Books: ["The Hitchhiker's Guide to the Galaxy", "So Long, and Thanks for All the Fish"] });
base.store("BookWriters").push({ Name: "Fyodor Dostoyevsky", Genre: "Drama", Books: ["Crime and Punishment", "Demons"] });
base.store("BookWriters").push({ Name: "J.R.R. Tolkien", Genre: "Fantasy", Books: ["The Hobbit", "The Two Towers", "The Silmarillion" ] });
base.store("BookWriters").push({ Name: "George R.R. Martin", Genre: "Fantasy", Books: ["A Game of Thrones", "A Feast of Crows"] });
base.store("BookWriters").push({ Name: "J. K. Rowling", Genre: "Fantasy", Books: ["Harry Potter and the Philosopher's Stone"] });
base.store("BookWriters").push({ Name: "Ivan Cankar", Genre: "Drama", Books: ["On the Hill", "The King of Betajnova", "The Serfs"] });
// create one record set containing all records of store
var recordSet = base.store("BookWriters").allRecords;
// create one record set containing the records with genre "Fantasy"
var fantasy = base.store("BookWriters").allRecords.filterByField("Genre", "Fantasy");
// delete the records in recordSet, that are also in fantasy
recordSet.deleteRecords(fantasy); // returns self, containing only three records: "Douglas Adams", "Fyodor Dostoyevsky" and "Ivan Cankar"
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" },
           { name: "Gender", type: "string" }
       ]
   }]
});
// put some records in the store
base.store("People").push({ Name: "Eric Sugar", Gender: "Male" });
base.store("People").push({ Name: "Jane Tokyo", Gender: "Female" });
base.store("People").push({ Name: "Mister Tea", Gender: "Male" });
// create a record set out of the records of the store
var recordSet = base.store("People").allRecords;
// change the Name of all records into "Anonymous"
recordSet.each(function (rec) { rec.Name = "Anonymous"; }); // returns self, all record's Name are "Anonymous"
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] });
// create a record set out of the records of the store
var recordSet = base.store("ArcheryChampionship").allRecords;
// filter the records: which archers have scored 48 points in the third round
recordSet.filter(function (rec) { return rec.ScorePerRound[2] == 48; }); // keeps only the records, where the score of the third round is equal 48
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: "WeatherForcast",
       fields: [
           { name: "Weather", type: "string" },
           { name: "Date", type: "datetime" },
           { name: "TemperatureDegrees", type: "int" },
       ]
   }]
});
// put some records in the "WeatherForecast" store
base.store("WeatherForcast").push({ Weather: "Partly Cloudy", Date: "2015-05-27T11:00:00", TemperatureDegrees: 19 });
base.store("WeatherForcast").push({ Weather: "Partly Cloudy", Date: "2015-05-28T11:00:00", TemperatureDegrees: 22 });
base.store("WeatherForcast").push({ Weather: "Mostly Cloudy", Date: "2015-05-29T11:00:00", TemperatureDegrees: 25 });
base.store("WeatherForcast").push({ Weather: "Mostly Cloudy", Date: "2015-05-30T11:00:00", TemperatureDegrees: 25 });
base.store("WeatherForcast").push({ Weather: "Scattered Showers", Date: "2015-05-31T11:00:00", TemperatureDegrees: 24 });
base.store("WeatherForcast").push({ Weather: "Mostly Cloudy", Date: "2015-06-01T11:00:00", TemperatureDegrees: 27 });
// get the record set containing the records from the "WeatherForcast" store
var recordSet = base.store("WeatherForcast").allRecords;
// filter only the records, where the weather is Mostly Cloudy
recordSet.filterByField("Weather", "Mostly Cloudy"); // returns self, containing only the records, where the weather is "Mostly Cloudy"
base.close();

// import qm require
var qm = require('qminer');
// create a new base containing one store
var base = new qm.Base({
   mode: "createClean",
   schema: [{
       name: "FrankSinatraGreatestHits",
       fields: [
           { name: "Title", type: "string" },
           { name: "Length", type: "int" }
       ]
   }]
});
// put some records in the "FrankSinatraGreatesHits" store
base.store("FrankSinatraGreatestHits").push({ Title: "Strangers in the Night", Length: 145 });
base.store("FrankSinatraGreatestHits").push({ Title: "Summer Wind", Length: 173 });
base.store("FrankSinatraGreatestHits").push({ Title: "It Was a Very Good Year", Length: 265 });
base.store("FrankSinatraGreatestHits").push({ Title: "Somewhere in Your Heart", Length: 146 });
base.store("FrankSinatraGreatestHits").push({ Title: "Forget Domani", Length: 156 });
base.store("FrankSinatraGreatestHits").push({ Title: "Somethin' Stupid", Length: 155 });
base.store("FrankSinatraGreatestHits").push({ Title: "This Town", Length: 186 });
// get the records of the store as a record set
var recordSet = base.store("FrankSinatraGreatestHits").allRecords;
// from the record set keep the records with indeces between or equal 2 and 5
recordSet.filterById(2, 5);
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] });
// create a record set of the records in store
var recordSet = base.store("ArcheryChampionship").allRecords;
// create a matrix from the "ScorePerRound" field
// the i-th column of the matrix is the data of the i-th record in record set
// the matrix will look like
// 50  44  50
// 48  46  50
// 48  44  48
var matrix = recordSet.getMatrix("ScorePerRound");
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 record set of the records of store
var recordSet = base.store("TVSeries").allRecords;
// create a vector containing the number of episodes for each series
// the vector will look like [75, 574, 94, 11, 47]
var vector = recordSet.getVector("NumberOfEpisodes");
base.close();

// import qm module
var qm = require('qminer');
// create a new base containing two stores, with join attributes
var base = new qm.Base({
   mode: "createClean",
   schema: [
   {
       name: "Musicians",
       fields: [
           { name: "Name", type: "string" },
           { name: "Instruments", type: "string_v" }
       ],
       joins: [
           { name: "PlaysIn", type: "index", store: "Bands", inverse: "Members" }
       ]
   },
   {
       name: "Bands",
       fields: [
           { name: "Name", type: "string" },
           { name: "Genre", type: "string" }
       ],
       joins: [
           { name: "Members", type: "index", store: "Musicians", inverse: "PlaysIn" }
       ]
   }]
});
// add some new records to both stores
base.store("Musicians").push({ Name: "Robert Plant", Instruments: ["Vocals"], PlaysIn: [{Name: "Led Zeppelin", "Genre": "Rock" }] });
base.store("Musicians").push({ Name: "Jimmy Page", Instruments: ["Guitar"], PlaysIn: [{Name: "Led Zeppelin", "Genre": "Rock" }] });
base.store("Bands").push({ Name: "The White Stripes", Genre: "Rock" });
// create a record set containing the musicians, that are members of some bend
// returns a record set containing the records of "Robert Plant" and "Jimmy Page"
var ledZeppelin = base.store("Bands").allRecords.join("Members");
// create a record set containing the first musician, that is a member of some band
// returns a record set containing only one record, which is "Robert Plant" or "Jimmy Page"
var ledMember = base.store("Bands").allRecords.join("Members", 1);
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" },
           { name: "Gender", type: "string" }
       ]
   }]
});
// put some records in the store
base.store("People").push({ Name: "Eric Sugar", Gender: "Male" });
base.store("People").push({ Name: "Jane Tokyo", Gender: "Female" });
base.store("People").push({ Name: "Mister Tea", Gender: "Male" });
// create a record set out of the records of the store
var recordSet = base.store("People").allRecords;
// make an array of record Names
var arr = recordSet.map(function (rec) { return rec.Name; }); // returns an array: ["Eric Sugar", "Jane Tokyo", "Mister Tea"]
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: "WeatherForcast",
       fields: [
           { name: "Weather", type: "string" },
           { name: "Date", type: "datetime" },
           { name: "TemperatureDegrees", type: "int" },
       ]
   }]
});
// put some records in the "WeatherForecast" store
base.store("WeatherForcast").push({ Weather: "Partly Cloudy", Date: "2015-05-27T11:00:00", TemperatureDegrees: 19 });
base.store("WeatherForcast").push({ Weather: "Partly Cloudy", Date: "2015-05-28T11:00:00", TemperatureDegrees: 22 });
base.store("WeatherForcast").push({ Weather: "Mostly Cloudy", Date: "2015-05-29T11:00:00", TemperatureDegrees: 25 });
base.store("WeatherForcast").push({ Weather: "Mostly Cloudy", Date: "2015-05-30T11:00:00", TemperatureDegrees: 25 });
base.store("WeatherForcast").push({ Weather: "Scattered Showers", Date: "2015-05-31T11:00:00", TemperatureDegrees: 24 });
base.store("WeatherForcast").push({ Weather: "Mostly Cloudy", Date: "2015-06-01T11:00:00", TemperatureDegrees: 27 });
// get the record set containing the records from the "WeatherForcast" store
var recordSet = base.store("WeatherForcast").allRecords;
// reverse the record order in the record set
recordSet.reverse(); // returns self, the records in the record set are in the reverse order
base.close();

// import qm module
var qm = require('qminer');
// create a new base with one store
var base = new qm.Base({
   mode: "createClean",
   schema: [{
       name: "Movies",
       fields: [
           { name: "Title", type: "string" },
           { name: "Length", type: "int" },
           { name: "Director", type: "string" }
       ]
   }]
});
// put some records in the store
base.store("Movies").push({ Title: "The Nightmare Before Christmas", Length: 76, Director: "Henry Selick" });
base.store("Movies").push({ Title: "Jurassic Part", Length: 127, Director: "Steven Spielberg" });
base.store("Movies").push({ Title: "The Avengers", Length: 143, Director: "Joss Whedon" });
base.store("Movies").push({ Title: "The Clockwork Orange", Length: 136, Director: "Stanley Kubrick" });
base.store("Movies").push({ Title: "Full Metal Jacket", Length: 116, Director: "Stanely Kubrick" });
// create a sample record set of containing 3 records from the "Movies" store
var sample = base.store("Movies").allRecords.sample(3);
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: "BookWriters",
       fields: [
           { name: "Name", type: "string" },
           { name: "Genre", type: "string" },
           { name: "Books", type: "string_v" }
       ]
   }]
});
// set new records in the store
base.store("BookWriters").push({ Name: "Terry Pratchett", Genre: "Fantasy", Books: ["The Colour of Magic", "Going Postal", "Mort", "Guards! Guards!"] });
base.store("BookWriters").push({ Name: "Douglas Adams", Genre: "Sci-fi", Books: ["The Hitchhiker's Guide to the Galaxy", "So Long, and Thanks for All the Fish"] });
base.store("BookWriters").push({ Name: "Fyodor Dostoyevsky", Genre: "Drama", Books: ["Crime and Punishment", "Demons"] });
base.store("BookWriters").push({ Name: "J.R.R. Tolkien", Genre: "Fantasy", Books: ["The Hobbit", "The Two Towers", "The Silmarillion" ] });
base.store("BookWriters").push({ Name: "George R.R. Martin", Genre: "Fantasy", Books: ["A Game of Thrones", "A Feast of Crows"] });
base.store("BookWriters").push({ Name: "J. K. Rowling", Genre: "Fantasy", Books: ["Harry Potter and the Philosopher's Stone"] });
base.store("BookWriters").push({ Name: "Ivan Cankar", Genre: "Drama", Books: ["On the Hill", "The King of Betajnova", "The Serfs"] });
// create one record set containing all records of store
var recordSet = base.store("BookWriters").allRecords;
// create one record set containing the records with genre "Fantasy"
var fantasy = base.store("BookWriters").allRecords.filterByField("Genre", "Fantasy");
// create a new record set containing the difference of recordSet and fantasy
var difference = recordSet.setDiff(fantasy); // returns a record set, containing the records of Douglas Adams, Fyodor Dostoyevsky and Ivan Cankar
base.close();

// import qm module
var qm = require('qminer');
// create a new base with one store
var base = new qm.Base({
   mode: "createClean",
   schema: [{
       name: "Movies",
       fields: [
           { name: "Title", type: "string" },
           { name: "Length", type: "int" },
           { name: "Director", type: "string" }
       ]
   }]
});
// put some records in the store
base.store("Movies").push({ Title: "The Nightmare Before Christmas", Length: 76, Director: "Henry Selick" });
base.store("Movies").push({ Title: "Jurassic Part", Length: 127, Director: "Steven Spielberg" });
base.store("Movies").push({ Title: "The Avengers", Length: 143, Director: "Joss Whedon" });
base.store("Movies").push({ Title: "The Clockwork Orange", Length: 136, Director: "Stanley Kubrick" });
base.store("Movies").push({ Title: "Full Metal Jacket", Length: 116, Director: "Stanely Kubrick" });
// create a record set out of the records in store, where length of the movie is greater than 110
var greaterSet = base.store("Movies").allRecords.filterByField("Length", 110, 150);
// create a record set out of the records in store, where the length of the movie is lesser than 130
var lesserSet = base.store("Movies").allRecords.filterByField("Length", 0, 130);
// get the intersection of greaterSet and lesserSet
var intersection = greaterSet.setIntersect(lesserSet); // returns a record set, containing the movies with lengths between 110 and 130
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 record set out of the records in store, where the number of episodes is lesser than 47
var lesserSet = base.store("TVSeries").allRecords.filterByField("NumberOfEpisodes", 0, 47);
// create a record set out of the records in store, where the number of episodes is greater than 100
var greaterSet = base.store("TVSeries").allRecords.filterByField("NumberOfEpisodes", 100, 600);
// get the union of lesserSet and greaterSet
var union = lesserSet.setUnion(greaterSet); // returns a record set, which is the union of the two record sets
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: "WeatherForcast",
       fields: [
           { name: "Weather", type: "string" },
           { name: "Date", type: "datetime" },
           { name: "TemperatureDegrees", type: "int" }
       ]
   }]
});
// put some records in the "WeatherForecast" store
base.store("WeatherForcast").push({ Weather: "Partly Cloudy", Date: "2015-05-27T11:00:00", TemperatureDegrees: 19 });
base.store("WeatherForcast").push({ Weather: "Partly Cloudy", Date: "2015-05-28T11:00:00", TemperatureDegrees: 22 });
base.store("WeatherForcast").push({ Weather: "Mostly Cloudy", Date: "2015-05-29T11:00:00", TemperatureDegrees: 25 });
base.store("WeatherForcast").push({ Weather: "Mostly Cloudy", Date: "2015-05-30T11:00:00", TemperatureDegrees: 25 });
base.store("WeatherForcast").push({ Weather: "Scattered Showers", Date: "2015-05-31T11:00:00", TemperatureDegrees: 24 });
base.store("WeatherForcast").push({ Weather: "Mostly Cloudy", Date: "2015-06-01T11:00:00", TemperatureDegrees: 27 });
// get the record set containing the records from the "WeatherForcast" store
var recordSet = base.store("WeatherForcast").allRecords;
// shuffle the records in the newly created record set. Use the number 100 as the seed for the shuffle
recordSet.shuffle(100); // returns self, the records in the record set are shuffled
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: "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 });
// get the records of the "TVSeries" store as a record set
var recordSet = base.store("TVSeries").allRecords;
// sort the records by their number of episodes
recordSet.sort(function (rec, rec2) { return rec.NumberOfEpisodes < rec2.NumberOfEpisodes; }); // returns self, records are sorted by the number of episodes
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: "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 });
// get the records of the "TVSeries" store as a record set
var recordSet = base.store("TVSeries").allRecords;
// sort the records by their "Title" field in ascending order
recordSet.sortByField("Title", true); // returns self, record are sorted by their "Title"
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: "Tea",
       fields: [
           { name: "Name", type: "string" },
           { name: "Type", type: "string"},
           { name: "Origin", type: "string", "null": true  }
       ]
   }]
});
// put some records in the "Tea" store
base.store("Tea").push({ Name: "Tanyang Gongfu", Type: "Black", Origin: "Tanyang" });
base.store("Tea").push({ Name: "Rou Gui", Type: "White" });
base.store("Tea").push({ Name: "Tieluohan Tea", Type: "Wuyi", Origin: "Northern Fujian" });
base.store("Tea").push({ Name: "Red Robe", Type: "Oolong", Origin: "Wuyi Mountains" });
// get the records of the "Tea" store as a record set
var recordSet = base.store("Tea").allRecords;
// sort the records in the record set by their id in descending order
recordSet.sortById(); // returns self, the records are sorted in descending order (default)
// sort the records in the record set by their id in ascending order
recordSet.sortById(1); // returns self, the records are sorted in ascending order
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: "SocialGames",
       fields: [
           { name: "Title", type: "string" },
           { name: "Type", type: "string" },
           { name: "MinPlayers", type: "int" },
           { name: "MaxPlayers", type: "int" }
       ]
   }]
});
// set new records in the store
base.store("SocialGames").push({ Title: "DungeonsAndDragons", Type: "Role-Playing", MinPlayers: 5, MaxPlayers: 5 });
base.store("SocialGames").push({ Title: "Dobble", Type: "Card", MinPlayers: 2, MaxPlayers: 8 });
base.store("SocialGames").push({ Title: "Settlers of Catan", Type: "Board", MinPlayers: 3, MaxPlayers: 4 });
base.store("SocialGames").push({ Title: "Munchkin", Type: "Card", MinPlayers: 3, MaxPlayers: 6 });
// create a record set out of the records of the store
var recordSet = base.store("SocialGames").allRecords;
// sort the records by MinPlayers in ascending order
recordSet.sortByField("MinPlayers", true);
// split the record set by the minimum number of players
// returns an array containing three record sets: the first containing the "DungeonsAndDragons" record,
// the second containing the "Settlers of Catan" and "Munchkin" records and the third containing the
// "Dobble" record
var arr = recordSet.split(function (rec, rec2) { return rec.MinPlayers < rec2.MinPlayers; });
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: "Musicians",
       fields: [
           { name: "Name", type: "string", primary: true },
           { name: "DateOfBirth", type: "datetime" },
           { name: "GreatestHits", type: "string_v" }
       ]
   }]
});
// create some records
base.store("Musicians").push({ Name: "Jimmy Page", DateOfBirth:  "1944-01-09T00:00:00", GreatestHits: ["Stairway to Heaven", "Whole Lotta Love"] });
base.store("Musicians").push({ Name: "Beyonce", DateOfBirth: "1981-09-04T00:00:00", GreatestHits: ["Single Ladies (Put a Ring on It)"] });
// create a record set out of the records in the "Musicians" store
var recordSet = base.store("Musicians").allRecords;
// create a JSON object out of the record set
var json = recordSet.toJSON();
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: "Philosophers",
       fields: [
           { name: "Name", type: "string" },
           { name: "Era", type: "string" }
       ]
   }]
});
// put some records in the store
base.store("Philosophers").push({ Name: "Plato", Era: "Ancient philosophy" });
base.store("Philosophers").push({ Name: "Immanuel Kant", Era: "18th-century philosophy" });
base.store("Philosophers").push({ Name: "Emmanuel Levinas", Era: "20th-century philosophy" });
base.store("Philosophers").push({ Name: "Rene Descartes", Era: "17th-century philosophy" });
base.store("Philosophers").push({ Name: "Confucius", Era: "Ancient philosophy" });
// create two identical record sets of the "Philosophers" store
var recordSet1 = base.store("Philosophers").allRecords;
var recordSet2 = base.store("Philosophers").allRecords;
// truncate the first 3 records in recordSet1
recordSet1.trunc(3); // return self, containing only the first 3 records ("Plato", "Immanuel Kant", "Emmanuel Levinas")
// truncate the first 2 records in recordSet2, starting with "Emmanuel Levinas"
recordSet2.trunc(2, 2); // returns self, containing only the 2 records ("Emmanuel Levinas", "Rene Descartes")
base.close();