_id stringlengths 2 6 | title stringlengths 0 58 | partition stringclasses 3
values | text stringlengths 27 233k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q50700 | nonRecord | train | function nonRecord(buffer, variable) {
// variable type
const type = types.str2num(variable.type);
// size of the data
var size = variable.size / types.num2bytes(type);
// iterates over the data
var data = new | javascript | {
"resource": ""
} |
q50701 | record | train | function record(buffer, variable, recordDimension) {
// variable type
const type = types.str2num(variable.type);
const width = variable.size ? variable.size / types.num2bytes(type) : 1;
// size of the data
// TODO streaming data
| javascript | {
"resource": ""
} |
q50702 | header | train | function header(buffer, version) {
// Length of record dimension
// sum of the varSize's of all the record variables.
var header = { recordDimension: { length: buffer.readUint32() } };
// Version
header.version = version;
// List of dimensions
var dimList = dimensionsList(buffer);
header.recordDimensi... | javascript | {
"resource": ""
} |
q50703 | dimensionsList | train | function dimensionsList(buffer) {
var recordId, recordName;
const dimList = buffer.readUint32();
if (dimList === ZERO) {
utils.notNetcdf((buffer.readUint32() !== ZERO), 'wrong empty tag for list of dimensions');
return [];
} else {
utils.notNetcdf((dimList !== NC_DIMENSION), 'wrong tag for list of d... | javascript | {
"resource": ""
} |
q50704 | attributesList | train | function attributesList(buffer) {
const gAttList = buffer.readUint32();
if (gAttList === ZERO) {
utils.notNetcdf((buffer.readUint32() !== ZERO), 'wrong empty tag for list of attributes');
return [];
} else {
utils.notNetcdf((gAttList !== NC_ATTRIBUTE), 'wrong tag for list of attributes');
// Leng... | javascript | {
"resource": ""
} |
q50705 | variablesList | train | function variablesList(buffer, recordId, version) {
const varList = buffer.readUint32();
var recordStep = 0;
if (varList === ZERO) {
utils.notNetcdf((buffer.readUint32() !== ZERO), 'wrong empty tag for list of variables');
return [];
} else {
utils.notNetcdf((varList !== NC_VARIABLE), 'wrong tag for... | javascript | {
"resource": ""
} |
q50706 | num2str | train | function num2str(type) {
switch (Number(type)) {
case types.BYTE:
return 'byte';
case types.CHAR:
return 'char';
case types.SHORT:
return 'short';
case types.INT:
return 'int';
case types.FLOAT:
return 'float'; | javascript | {
"resource": ""
} |
q50707 | str2num | train | function str2num(type) {
switch (String(type)) {
case 'byte':
return types.BYTE;
case 'char':
return types.CHAR;
case 'short':
return types.SHORT;
case 'int':
return types.INT;
case 'float':
return types.FLOAT; | javascript | {
"resource": ""
} |
q50708 | readNumber | train | function readNumber(size, bufferReader) {
if (size !== 1) {
var numbers = new Array(size);
for (var i = 0; i < size; i++) {
| javascript | {
"resource": ""
} |
q50709 | readType | train | function readType(buffer, type, size) {
switch (type) {
case types.BYTE:
return buffer.readBytes(size);
case types.CHAR:
return trimNull(buffer.readChars(size));
case types.SHORT:
return readNumber(size, buffer.readInt16.bind(buffer));
| javascript | {
"resource": ""
} |
q50710 | trimNull | train | function trimNull(value) {
if (value.charCodeAt(value.length - 1) === 0) {
| javascript | {
"resource": ""
} |
q50711 | readName | train | function readName(buffer) {
// Read name
var nameLength = buffer.readUint32();
var name = buffer.readChars(nameLength);
// validate | javascript | {
"resource": ""
} |
q50712 | exif2css | train | function exif2css(orientation) {
const s = `${orientation}`
const transforms = transformsMap[s]
const transform = expandTransform(transforms)
const transformOrigin = transformOriginMap[s]
const allTransforms = expandTransforms(transforms)
const allTransformStrings = expandTransformStrings(transforms)
co... | javascript | {
"resource": ""
} |
q50713 | defaultMockFilename | train | function defaultMockFilename(config, req) {
var reqData = prismUtils.filterUrl(config, req.url);
// include request body in hash
if (config.hashFullRequest(config, req)) {
reqData = req.body + reqData;
| javascript | {
"resource": ""
} |
q50714 | isExternalLinkTarget | train | function isExternalLinkTarget(target) {
return target === "_blank" ||
(target === "_parent" && window.parent | javascript | {
"resource": ""
} |
q50715 | train | function(escape) {
var pairs = this.pairs;
var type = this.type;
var names = Object.keys(pairs);
var html = "";
var escapeHtml = escape || IDENTITY;
var name;
var computedType;
for (var i = 0, len = names.length; i < len; i++) {
| javascript | {
"resource": ""
} | |
q50716 | addIntegerSeparators | train | function addIntegerSeparators(x, separator) {
x += '';
if (!separator) return x; | javascript | {
"resource": ""
} |
q50717 | addDecimalSeparators | train | function addDecimalSeparators(x, separator) {
x += '';
if (!separator) return x; | javascript | {
"resource": ""
} |
q50718 | padLeft | train | function padLeft(x, padding) {
x = x + '';
var buf = [];
while (buf.length + x.length < padding) {
| javascript | {
"resource": ""
} |
q50719 | padRight | train | function padRight(x, padding) {
if (x) {
x += '';
} else {
x = '';
| javascript | {
"resource": ""
} |
q50720 | schematize | train | function schematize(content, name) {
return content
.replace(new RegExp(`${name}`, 'g'), '<%= dasherize(name) %>', 'g')
.replace(new RegExp(`${classify(name)}`, 'g'), '<%= classify(name) %>', 'g')
| javascript | {
"resource": ""
} |
q50721 | setSearchTerm | train | function setSearchTerm(searchTerm, currentParams) {
let newParams = {
...currentParams,
page: undefined, //set page undefined to return the table to page 1
searchTerm: searchTerm === defaults.searchTerm ? undefined | javascript | {
"resource": ""
} |
q50722 | cleanupFilter | train | function cleanupFilter(filter) {
let filterToUse = filter;
if (
filterToUse.selectedFilter === "inList" &&
typeof filterToUse.filterValue === "number"
) {
filterToUse = {
| javascript | {
"resource": ""
} |
q50723 | processTag | train | function processTag(tag, targets) {
if (tag.description) {
tag.description = replaceLink(tag.description, targets);
}
if (tag.params) {
tag.params.forEach(function (param) {
if (param.description) {
param.description = replaceLink(param.description, targets);
}
});
}
if (tag.me... | javascript | {
"resource": ""
} |
q50724 | setPipedTypesString | train | function setPipedTypesString(node) {
if (!node.type) | javascript | {
"resource": ""
} |
q50725 | addListenersToStream | train | function addListenersToStream(listeners, stream) {
var evt, callback;
if (listeners) {
for (evt in listeners) {
| javascript | {
"resource": ""
} |
q50726 | chain | train | function chain(a, b) {
var prop, descriptor = {};
for (prop in a) {
if (a.hasOwnProperty(prop)) { | javascript | {
"resource": ""
} |
q50727 | getRootCerts | train | function getRootCerts(callback) {
return request(certUrl, function(err, res, body) {
if (err) return callback(err);
// Delete preprocesor macros
body = body.replace(/#[^\n]+/g, '');
// Delete the trailing comma
body = body.replace(/,\s*$/, '');
// Make sure each C string is concatenated
... | javascript | {
"resource": ""
} |
q50728 | interpretTwoDigitYear | train | function interpretTwoDigitYear(year) {
const thisYear = new Date().getFullYear();
const thisCentury = thisYear - (thisYear % 100);
const centuries | javascript | {
"resource": ""
} |
q50729 | get | train | function get(object, key, ...args) {
if (object) {
const value = object[key];
| javascript | {
"resource": ""
} |
q50730 | setContainerProperties | train | function setContainerProperties(blobSvc, options, result, callback) {
blobSvc.getServiceProperties(function(error, result, response) {
if (error) {
return callback(error);
}
var serviceProperties = result;
var allowedOrigins = options.allowedOrigins || ['*'];
var allowedMethods = options.all... | javascript | {
"resource": ""
} |
q50731 | initializeContainer | train | function initializeContainer(blobSvc, container, options, callback) {
blobSvc.setContainerAcl(container, null, { publicAccessLevel: 'container' }, function(error, result, response) {
if (error) {
| javascript | {
"resource": ""
} |
q50732 | createContainer | train | function createContainer(cluster, options, callback) {
var blobSvc = azure.createBlobService(cluster.account, cluster.key);
var container = cluster.container || options.container;
blobSvc.createContainerIfNotExists(container, function(error, result, response) { | javascript | {
"resource": ""
} |
q50733 | createContainerBlob | train | function createContainerBlob(blob, path, localPath, _gzip, callback) {
// Draw the extension from uploadfs, where we know they will be using
// reasonable extensions, not from what could be a temporary file
// that came from the gzip code. -Tom
var extension = extname(path).substring(1);
var contentSettings =... | javascript | {
"resource": ""
} |
q50734 | removeContainerBlob | train | function removeContainerBlob(blob, path, callback) {
blob.svc.deleteBlobIfExists(blob.container, path, function(error, result, response) {
if (error) {
__log('Cannot delete | javascript | {
"resource": ""
} |
q50735 | train | function(gzipEncoding) {
var gzipSettings = gzipEncoding || {};
var { whitelist, blacklist } = Object.keys(gzipSettings).reduce((prev, key) => {
if (gzipSettings[key]) {
prev['whitelist'].push(key);
| javascript | {
"resource": ""
} | |
q50736 | some | train | function some(array, predict) {
for (let i = 0; i < array.length; i++) {
if (predict(array[i])) { | javascript | {
"resource": ""
} |
q50737 | train | function(path, disabledFileKey) {
var hmac = crypto.createHmac('sha256', disabledFileKey);
hmac.update(path);
| javascript | {
"resource": ""
} | |
q50738 | train | function (callback) {
if (!imageSizes.length) {
return callback();
}
tempPath = options.tempPath;
if (!fs.existsSync(options.tempPath)) {
| javascript | {
"resource": ""
} | |
q50739 | train | function (callback) {
if (!self._image) {
var paths = (process.env.PATH || '').split(delimiter);
if (!_.find(paths, function(p) {
if (fs.existsSync(p + '/imagecrunch')) {
self._image = require('./lib/image/imagecrunch.js')();
return true;
}... | javascript | {
"resource": ""
} | |
q50740 | identify | train | function identify(path, callback) {
return self.identifyLocalImage(path, function(err, info) {
if (err) {
return callback(err);
}
context.info = info;
| javascript | {
"resource": ""
} |
q50741 | train | function (callback) {
// Name the destination folder
context.tempName = generateId();
// Create destination folder
| javascript | {
"resource": ""
} | |
q50742 | train | function (callback) {
context.basePath = path.replace(/\.\w+$/, '');
context.workingPath = localPath;
// Indulge their wild claims about the extension the original
// should have if any, otherwise provide the truth from identify
if (path.match(/\.\w+$/)) {
| javascript | {
"resource": ""
} | |
q50743 | train | function(callback) {
if (!context.copyOriginal) {
return callback(null);
}
var suffix = 'original.' + context.extension;
var tempFile = context.tempFolder + '/' + suffix;
if (context.extension !== 'jpg') {
// Don't forget to tell the caller that ... | javascript | {
"resource": ""
} | |
q50744 | mapValueCast | train | function mapValueCast (value) {
index++
parameters.push(inputValue(value))
let cast = ''
if (Buffer.isBuffer(value))
cast = '::bytea'
| javascript | {
"resource": ""
} |
q50745 | generateIndex | train | function generateIndex (playbook, pages) {
let siteUrl = playbook.site.url
if (!siteUrl) {
// Uses relative links when site URL is not set
siteUrl = '';
}
if (siteUrl.charAt(siteUrl.length - 1) === '/') siteUrl = siteUrl.substr(0, siteUrl.length - 1)
if (!pages.length) return {}
// Map of Lunr ref t... | javascript | {
"resource": ""
} |
q50746 | _translate | train | function _translate(duration, ease = '', x = false) {
| javascript | {
"resource": ""
} |
q50747 | slide | train | function slide(direction) {
const movement = direction === true ? 1 : -1
let duration = slideSpeed
// calculate the nextIndex according to the movement
let nextIndex = index + 1 * movement
// nextIndex should be between 0 and items minus 1
nextIndex = clampNumber(nextIndex, 0, items - 1)
... | javascript | {
"resource": ""
} |
q50748 | _setup | train | function _setup() {
slidesDOMEl.addEventListener(TRANSITION_END, onTransitionEnd)
containerDOMEl.addEventListener('touchstart', onTouchstart, EVENT_OPTIONS)
containerDOMEl.addEventListener('touchmove', onTouchmove, EVENT_OPTIONS)
| javascript | {
"resource": ""
} |
q50749 | train | function(options) {
return {
element: options.element,
name: 'Do not use ' + options.element + ' element',
message: 'Please remove the ' + options.element + ' element',
ruleUrl: options.ruleUrl, | javascript | {
"resource": ""
} | |
q50750 | train | function(element) {
'use strict';
return function(dom, reporter) {
var that = this;
dom.$(element).each(function(index, | javascript | {
"resource": ""
} | |
q50751 | customLogic | train | function customLogic (os, name, file, cb) {
var logic = './logic/' | javascript | {
"resource": ""
} |
q50752 | RestrictedInput | train | function RestrictedInput(options) {
options = options || {};
if (!isValidElement(options.element)) {
throw new Error(constants.errors.INVALID_ELEMENT);
}
if (!options.pattern) {
throw new Error(constants.errors.PATTERN_MISSING);
}
if (!RestrictedInput.supportsFormatting()) {
this.strategy = n... | javascript | {
"resource": ""
} |
q50753 | Sticky | train | function Sticky(head, title, toc, page, gradientBit) {
page.style.paddingTop = maxHeadHeight;
head.style.height = maxHeadHeight + "px";
var padding = minHeadPadding + ((maxHeadPadding - minHeadPadding) * ((maxHeadHeight - minHeadHeight) / (maxHeadHeight - minHeadHeight)));
head.style.padding = padding +... | javascript | {
"resource": ""
} |
q50754 | cm2feetInches | train | function cm2feetInches (cm) {
const totalInches = (cm * 0.393701);
let feet = Math.floor(totalInches / | javascript | {
"resource": ""
} |
q50755 | PCRE | train | function PCRE (pattern, namedCaptures) {
pattern = String(pattern || '').trim();
var originalPattern = pattern;
var delim;
var flags = '';
// A delimiter can be any non-alphanumeric, non-backslash,
// non-whitespace character.
var hasDelim = /^[^a-zA-Z\\\s]/.test(pattern);
if (hasDelim) {
delim = p... | javascript | {
"resource": ""
} |
q50756 | replaceCaptureGroups | train | function replaceCaptureGroups (pattern, fn) {
var start;
var depth = 0;
var escaped = false;
for (var i = 0; i < pattern.length; i++) {
var cur = pattern[i];
if (escaped) {
// skip this letter, it's been escaped
escaped = false;
continue;
}
switch (cur) {
case '(':
... | javascript | {
"resource": ""
} |
q50757 | renderPick | train | function renderPick() {
if(checkContextLoss()) {
return
}
gl.colorMask(true, true, true, true)
gl.depthMask(true)
gl.disable(gl.BLEND)
gl.enable(gl.DEPTH_TEST)
var numObjs = objects.length
var numPick = pickBuffers.length
for(var j=0; j<numPick; ++j) {
var buf = pickBuf... | javascript | {
"resource": ""
} |
q50758 | walkDepthFirst | train | function walkDepthFirst (tree, visitor) {
const val = walkDepthFirstRecursive(tree, visitor)
if (val !== undefined) {
| javascript | {
"resource": ""
} |
q50759 | newPosId | train | function newPosId (p, f) {
const pPath = p && p[0]
const fPath = f && f[0]
let path
let uid
if (pPath && fPath && isSibling(pPath, fPath)) {
path = [pPath[0], pPath[1]]
| javascript | {
"resource": ""
} |
q50760 | color | train | function color(c, group) {
if (c == null) c = Scatter.defaults.color;
c | javascript | {
"resource": ""
} |
q50761 | marker | train | function marker(markers, group, options) {
var activation = group.activation; // reset marker elements
activation.forEach(function (buffer) {
return buffer && buffer.destroy && buffer.destroy();
});
activation.length = 0; // single sdf marker
if (!markers || typeof ma... | javascript | {
"resource": ""
} |
q50762 | jql | train | function jql(queryChunks, ...injects) {
try {
let res = '';
for (let i = 0; i < injects.length; i++) {
let value = injects[i];
let q = queryChunks[i];
if (typeof value === 'string') {
//make string value safe
value = cleanStrin... | javascript | {
"resource": ""
} |
q50763 | Ca | train | function Ca (A, B, M0, M1) {
this.A = A
this.B = B
| javascript | {
"resource": ""
} |
q50764 | identifyRefsInSchemaFields | train | function identifyRefsInSchemaFields(structure, prefix) {
_.each(structure.schema, (fieldStructure, fieldName) => {
const name = prefix ? prefix + '.' + fieldName : fieldName;
//If field has a schema, then it is a collection
if (fieldStructure.schema) {
// ... | javascript | {
"resource": ""
} |
q50765 | train | function (str) {
return str.replace
(/(^[a-z]+)|[0-9]+|[A-Z][a-z]+|[A-Z]+(?=[A-Z][a-z]|[0-9])/g
| javascript | {
"resource": ""
} | |
q50766 | modf | train | function modf (float) {
const i = Math.trunc(float)
const f | javascript | {
"resource": ""
} |
q50767 | round | train | function round (float, precision) {
precision = (precision | javascript | {
"resource": ""
} |
q50768 | _compatibility | train | function _compatibility (rs) {
const _rs = [rs.rise, rs.transit, rs.set]
_rs.rise = rs.rise
_rs.transit | javascript | {
"resource": ""
} |
q50769 | interpolate | train | function interpolate (dyear, data) {
const d3 = interp.len3ForInterpolateX(dyear,
| javascript | {
"resource": ""
} |
q50770 | interpolateData | train | function interpolateData (dyear, data) {
const [fyear, fmonth] = data.firstYM
const {year, month, first, last} = monthOfYear(dyear)
const pos = 12 * (year - fyear) + (month - fmonth)
const table | javascript | {
"resource": ""
} |
q50771 | monthOfYear | train | function monthOfYear (dyear) {
if (!monthOfYear.data) { // memoize yearly fractions per month
monthOfYear.data = {0: [], 1: []}
for (let m = 0; m <= 12; m++) {
monthOfYear.data[0][m] = new Calendar(1999, m, 1).toYear() - 1999 // non leap year
monthOfYear.data[1][m] = new Calendar(2000, m, 1).toYea... | javascript | {
"resource": ""
} |
q50772 | appendRecursively | train | function appendRecursively(formData, collection, parentkey, parentIsArray) {
//console.log(...arguments)
for (let k in collection) {
const val = collection[k];
if (val === undefined) continue;
if (val instanceof File) {
let mkey = (parentkey ? parentkey + '.' : '') + k;
... | javascript | {
"resource": ""
} |
q50773 | snap | train | function snap (y, q) {
const k = (y - 2000) | javascript | {
"resource": ""
} |
q50774 | read | train | function read (value) {
if (value instanceof RegExp) {
var chars = source.slice(index)
var match = chars.match(value)
if (match) {
index += match[0].length
return match[0]
}
} else | javascript | {
"resource": ""
} |
q50775 | parse | train | function parse(string) {
var match = isoDateExpression.exec(string);
if (match) {
// parse months, days, hours, minutes, seconds, and milliseconds
// provide default values if necessary
// parse the UTC offset component
var year = $... | javascript | {
"resource": ""
} |
q50776 | sameLength | train | function sameLength(a, b) {
return typeof a === typeof b &&
| javascript | {
"resource": ""
} |
q50777 | allSame | train | function allSame(arr) {
if (!check.array(arr)) {
return false;
}
if (!arr.length) {
return true;
}
| javascript | {
"resource": ""
} |
q50778 | oneOf | train | function oneOf(arr, x) {
check.verify.array(arr, | javascript | {
"resource": ""
} |
q50779 | has | train | function has(o, property) {
if (arguments.length !== 2) {
throw new Error('Expected two arguments to check.has, got only ' + arguments.length);
}
return Boolean(o && property | javascript | {
"resource": ""
} |
q50780 | badItems | train | function badItems(rule, a) {
check.verify.array(a, 'expected array to find bad items');
| javascript | {
"resource": ""
} |
q50781 | arrayOfStrings | train | function arrayOfStrings(a, checkLowerCase) {
var v = check.array(a) && a.every(check.string);
if (v && check.bool(checkLowerCase) && | javascript | {
"resource": ""
} |
q50782 | arrayOfArraysOfStrings | train | function arrayOfArraysOfStrings(a, checkLowerCase) {
return check.array(a) && a.every(function (arr) {
| javascript | {
"resource": ""
} |
q50783 | all | train | function all(obj, predicates) {
check.verify.fn(check.every, 'missing check.every method');
check.verify.fn(check.map, 'missing check.map method');
check.verify.object(obj, 'missing object to check');
check.verify.object(predicates, 'missing predicates object');
Object.keys(predicates).forEach(func... | javascript | {
"resource": ""
} |
q50784 | raises | train | function raises(fn, errorValidator) {
check.verify.fn(fn, 'expected function that raises');
try {
fn();
} catch (err) {
if (typeof errorValidator === 'undefined') {
return true;
}
if (typeof errorValidator === 'function') {
| javascript | {
"resource": ""
} |
q50785 | unempty | train | function unempty(a) {
var hasLength = typeof a === 'string' ||
Array.isArray(a);
if (hasLength) {
return a.length;
}
| javascript | {
"resource": ""
} |
q50786 | commitId | train | function commitId(id) {
return check.string(id) &&
id.length === | javascript | {
"resource": ""
} |
q50787 | shortCommitId | train | function shortCommitId(id) {
return check.string(id) &&
id.length === | javascript | {
"resource": ""
} |
q50788 | or | train | function or() {
var predicates = Array.prototype.slice.call(arguments, 0);
if (!predicates.length) {
throw new Error('empty list of arguments to or');
}
return function orCheck() {
var values = Array.prototype.slice.call(arguments, 0);
return predicates.some(function (predicate) {
... | javascript | {
"resource": ""
} |
q50789 | and | train | function and() {
var predicates = Array.prototype.slice.call(arguments, 0);
if (!predicates.length) {
throw new Error('empty list of arguments to or');
}
return function orCheck() {
var values = Array.prototype.slice.call(arguments, 0);
| javascript | {
"resource": ""
} |
q50790 | verifyModifier | train | function verifyModifier(predicate, defaultMessage) {
return function () {
var message;
if (predicate.apply(null, arguments) === | javascript | {
"resource": ""
} |
q50791 | getLegacyRepo | train | function getLegacyRepo(env) {
// default to process.env if no argument provided
if (!env) { env = process.env }
// bail if neither variable exists
let remote = env.DRONE_REMOTE || env.CI_REMOTE
if (!remote) { return '' }
// parse out the org | javascript | {
"resource": ""
} |
q50792 | getStreams | train | function getStreams(config) {
// Any passed in streams
const streams = Array.isArray(config.streams)
? [...config.streams]
: [];
// Nice console output
if (config.stdout) {
streams.push({
name: 'stdout',
level: config.level,
stream: new ClientConsoleLogger(),
type: 'raw',
... | javascript | {
"resource": ""
} |
q50793 | getStreams | train | function getStreams(config) {
const streams = Array.isArray(config.streams)
? [...config.streams]
: [];
// Nice output to stdout
if (config.stdout) {
streams.push({
name: 'stdout',
level: config.level,
stream: bunyanFormat({ outputMode: 'short' }),
type: 'stream',
});
}
... | javascript | {
"resource": ""
} |
q50794 | getDependents | train | function getDependents(dependencyName) {
return Object.values(allPackages).filter(({info: pkg}) => {
return (
pkg.dependencies &&
| javascript | {
"resource": ""
} |
q50795 | train | function(key, success, error) {
success = success || noop;
error = error || noop;
| javascript | {
"resource": ""
} | |
q50796 | train | function(creditCard, success, error) {
success = success || noop;
error = error || noop;
| javascript | {
"resource": ""
} | |
q50797 | train | function(bankAccount, success, error) {
success = success || noop;
error = error || noop;
| javascript | {
"resource": ""
} | |
q50798 | train | function(cardNumber, success, error) {
success = success || noop;
error = error || noop;
| javascript | {
"resource": ""
} | |
q50799 | train | function(expMonth, expYear, success, error) {
success = success || noop;
error = error || noop;
| javascript | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.