perspective-dev.github.io/python/search.js at main · perspective-dev/perspective-dev.github.io

46 lines (43 loc) · 211 KB

window.pdocSearch = (function(){

/** elasticlunr - http://weixsong.github.io * Copyright (C) 2017 Oliver Nightingale * Copyright (C) 2017 Wei Song * MIT Licensed */!function(){function e(e){if(null===e||"object"!=typeof e)return e;var t=e.constructor();for(var n in e)e.hasOwnProperty(n)&&(t[n]=e[n]);return t}var t=function(e){var n=new t.Index;return n.pipeline.add(t.trimmer,t.stopWordFilter,t.stemmer),e&&e.call(n,n),n};t.version="0.9.5",lunr=t,t.utils={},t.utils.warn=function(e){return function(t){e.console&&console.warn&&console.warn(t)}}(this),t.utils.toString=function(e){return void 0===e||null===e?"":e.toString()},t.EventEmitter=function(){this.events={}},t.EventEmitter.prototype.addListener=function(){var e=Array.prototype.slice.call(arguments),t=e.pop(),n=e;if("function"!=typeof t)throw new TypeError("last argument must be a function");n.forEach(function(e){this.hasHandler(e)||(this.events[e]=[]),this.events[e].push(t)},this)},t.EventEmitter.prototype.removeListener=function(e,t){if(this.hasHandler(e)){var n=this.events[e].indexOf(t);-1!==n&&(this.events[e].splice(n,1),0==this.events[e].length&&delete this.events[e])}},t.EventEmitter.prototype.emit=function(e){if(this.hasHandler(e)){var t=Array.prototype.slice.call(arguments,1);this.events[e].forEach(function(e){e.apply(void 0,t)},this)}},t.EventEmitter.prototype.hasHandler=function(e){return e in this.events},t.tokenizer=function(e){if(!arguments.length||null===e||void 0===e)return[];if(Array.isArray(e)){var n=e.filter(function(e){return null===e||void 0===e?!1:!0});n=n.map(function(e){return t.utils.toString(e).toLowerCase()});var i=[];return n.forEach(function(e){var n=e.split(t.tokenizer.seperator);i=i.concat(n)},this),i}return e.toString().trim().toLowerCase().split(t.tokenizer.seperator)},t.tokenizer.defaultSeperator=/[\s\-]+/,t.tokenizer.seperator=t.tokenizer.defaultSeperator,t.tokenizer.setSeperator=function(e){null!==e&&void 0!==e&&"object"==typeof e&&(t.tokenizer.seperator=e)},t.tokenizer.resetSeperator=function(){t.tokenizer.seperator=t.tokenizer.defaultSeperator},t.tokenizer.getSeperator=function(){return t.tokenizer.seperator},t.Pipeline=function(){this._queue=[]},t.Pipeline.registeredFunctions={},t.Pipeline.registerFunction=function(e,n){n in t.Pipeline.registeredFunctions&&t.utils.warn("Overwriting existing registered function: "+n),e.label=n,t.Pipeline.registeredFunctions[n]=e},t.Pipeline.getRegisteredFunction=function(e){return e in t.Pipeline.registeredFunctions!=!0?null:t.Pipeline.registeredFunctions[e]},t.Pipeline.warnIfFunctionNotRegistered=function(e){var n=e.label&&e.label in this.registeredFunctions;n||t.utils.warn("Function is not registered with pipeline. This may cause problems when serialising the index.\n",e)},t.Pipeline.load=function(e){var n=new t.Pipeline;return e.forEach(function(e){var i=t.Pipeline.getRegisteredFunction(e);if(!i)throw new Error("Cannot load un-registered function: "+e);n.add(i)}),n},t.Pipeline.prototype.add=function(){var e=Array.prototype.slice.call(arguments);e.forEach(function(e){t.Pipeline.warnIfFunctionNotRegistered(e),this._queue.push(e)},this)},t.Pipeline.prototype.after=function(e,n){t.Pipeline.warnIfFunctionNotRegistered(n);var i=this._queue.indexOf(e);if(-1===i)throw new Error("Cannot find existingFn");this._queue.splice(i+1,0,n)},t.Pipeline.prototype.before=function(e,n){t.Pipeline.warnIfFunctionNotRegistered(n);var i=this._queue.indexOf(e);if(-1===i)throw new Error("Cannot find existingFn");this._queue.splice(i,0,n)},t.Pipeline.prototype.remove=function(e){var t=this._queue.indexOf(e);-1!==t&&this._queue.splice(t,1)},t.Pipeline.prototype.run=function(e){for(var t=[],n=e.length,i=this._queue.length,o=0;n>o;o++){for(var r=e[o],s=0;i>s&&(r=this._queue[s](r,o,e),void 0!==r&&null!==r);s++);void 0!==r&&null!==r&&t.push(r)}return t},t.Pipeline.prototype.reset=function(){this._queue=[]},t.Pipeline.prototype.get=function(){return this._queue},t.Pipeline.prototype.toJSON=function(){return this._queue.map(function(e){return t.Pipeline.warnIfFunctionNotRegistered(e),e.label})},t.Index=function(){this._fields=[],this._ref="id",this.pipeline=new t.Pipeline,this.documentStore=new t.DocumentStore,this.index={},this.eventEmitter=new t.EventEmitter,this._idfCache={},this.on("add","remove","update",function(){this._idfCache={}}.bind(this))},t.Index.prototype.on=function(){var e=Array.prototype.slice.call(arguments);return this.eventEmitter.addListener.apply(this.eventEmitter,e)},t.Index.prototype.off=function(e,t){return this.eventEmitter.removeListener(e,t)},t.Index.load=function(e){e.version!==t.version&&t.utils.warn("version mismatch: current "+t.version+" importing "+e.version);var n=new this;n._fields=e.fields,n._ref=e.ref,n.documentStore=t.DocumentStore.load(e.documentStore),n.pipeline=t.Pipeline.load(e.pipeline),n.index={};for(var i in e.index)n.index[i]=t.InvertedIndex.load(e.index[i]);return n},t.Index.prototype.addField=function(e){return this._fields.push(e),this.index[e]=new t.InvertedIndex,this},t.Index.prototype.setRef=function(e){return this._ref=e,this},t.Index.prototype.saveDocument=function(e){return this.documentStore=new t.DocumentStore(e),this},t.Index.prototype.addDoc=function(e,n){if(e){var n=void 0===n?!0:n,i=e[this._ref];this.documentStore.addDoc(i,e),this._fields.forEach(function(n){var o=this.pipeline.run(t.tokenizer(e[n]));this.documentStore.addFieldLength(i,n,o.length);var r={};o.forEach(function(e){e in r?r[e]+=1:r[e]=1},this);for(var s in r){var u=r[s];u=Math.sqrt(u),this.index[n].addToken(s,{ref:i,tf:u})}},this),n&&this.eventEmitter.emit("add",e,this)}},t.Index.prototype.removeDocByRef=function(e){if(e&&this.documentStore.isDocStored()!==!1&&this.documentStore.hasDoc(e)){var t=this.documentStore.getDoc(e);this.removeDoc(t,!1)}},t.Index.prototype.removeDoc=function(e,n){if(e){var n=void 0===n?!0:n,i=e[this._ref];this.documentStore.hasDoc(i)&&(this.documentStore.removeDoc(i),this._fields.forEach(function(n){var o=this.pipeline.run(t.tokenizer(e[n]));o.forEach(function(e){this.index[n].removeToken(e,i)},this)},this),n&&this.eventEmitter.emit("remove",e,this))}},t.Index.prototype.updateDoc=function(e,t){var t=void 0===t?!0:t;this.removeDocByRef(e[this._ref],!1),this.addDoc(e,!1),t&&this.eventEmitter.emit("update",e,this)},t.Index.prototype.idf=function(e,t){var n="@"+t+"/"+e;if(Object.prototype.hasOwnProperty.call(this._idfCache,n))return this._idfCache[n];var i=this.index[t].getDocFreq(e),o=1+Math.log(this.documentStore.length/(i+1));return this._idfCache[n]=o,o},t.Index.prototype.getFields=function(){return this._fields.slice()},t.Index.prototype.search=function(e,n){if(!e)return[];e="string"==typeof e?{any:e}:JSON.parse(JSON.stringify(e));var i=null;null!=n&&(i=JSON.stringify(n));for(var o=new t.Configuration(i,this.getFields()).get(),r={},s=Object.keys(e),u=0;u<s.length;u++){var a=s[u];r[a]=this.pipeline.run(t.tokenizer(e[a]))}var l={};for(var c in o){var d=r[c]||r.any;if(d){var f=this.fieldSearch(d,c,o),h=o[c].boost;for(var p in f)f[p]=f[p]*h;for(var p in f)p in l?l[p]+=f[p]:l[p]=f[p]}}var v,g=[];for(var p in l)v={ref:p,score:l[p]},this.documentStore.hasDoc(p)&&(v.doc=this.documentStore.getDoc(p)),g.push(v);return g.sort(function(e,t){return t.score-e.score}),g},t.Index.prototype.fieldSearch=function(e,t,n){var i=n[t].bool,o=n[t].expand,r=n[t].boost,s=null,u={};return 0!==r?(e.forEach(function(e){var n=[e];1==o&&(n=this.index[t].expandToken(e));var r={};n.forEach(function(n){var o=this.index[t].getDocs(n),a=this.idf(n,t);if(s&&"AND"==i){var l={};for(var c in s)c in o&&(l[c]=o[c]);o=l}n==e&&this.fieldSearchStats(u,n,o);for(var c in o){var d=this.index[t].getTermFrequency(n,c),f=this.documentStore.getFieldLength(c,t),h=1;0!=f&&(h=1/Math.sqrt(f));var p=1;n!=e&&(p=.15*(1-(n.length-e.length)/n.length));var v=d*a*h*p;c in r?r[c]+=v:r[c]=v}},this),s=this.mergeScores(s,r,i)},this),s=this.coordNorm(s,u,e.length)):void 0},t.Index.prototype.mergeScores=function(e,t,n){if(!e)return t;if("AND"==n){var i={};for(var o in t)o in e&&(i[o]=e[o]+t[o]);return i}for(var o in t)o in e?e[o]+=t[o]:e[o]=t[o];return e},t.Index.prototype.fieldSearchStats=function(e,t,n){for(var i in n)i in e?e[i].push(t):e[i]=[t]},t.Index.prototype.coordNorm=function(e,t,n){for(var i in e)if(i in t){var o=t[i].length;e[i]=e[i]*o/n}return e},t.Index.prototype.toJSON=function(){var e={};return this._fields.forEach(function(t){e[t]=this.index[t].toJSON()},this),{version:t.version,fields:this._fields,ref:this._ref,documentStore:this.documentStore.toJSON(),index:e,pipeline:this.pipeline.toJSON()}},t.Index.prototype.use=function(e){var t=Array.prototype.slice.call(arguments,1);t.unshift(this),e.apply(this,t)},t.DocumentStore=function(e){this._save=null===e||void 0===e?!0:e,this.docs={},this.docInfo={},this.length=0},t.DocumentStore.load=function(e){var t=new this;return t.length=e.length,t.docs=e.docs,t.docInfo=e.docInfo,t._save=e.save,t},t.DocumentStore.prototype.isDocStored=function(){return this._save},t.DocumentStore.prototype.addDoc=function(t,n){this.hasDoc(t)||this.length++,this.docs[t]=this._save===!0?e(n):null},t.DocumentStore.prototype.getDoc=function(e){return this.hasDoc(e)===!1?null:this.docs[e]},t.DocumentStore.prototype.hasDoc=function(e){return e in this.docs},t.DocumentStore.prototype.removeDoc=function(e){this.hasDoc(e)&&(delete this.docs[e],delete this.docInfo[e],this.length--)},t.DocumentStore.prototype.addFieldLength=function(e,t,n){null!==e&&void 0!==e&&0!=this.hasDoc(e)&&(this.docInfo[e]||(this.docInfo[e]={}),this.docInfo[e][t]=n)},t.DocumentStore.prototype.updateFieldLength=function(e,t,n){null!==e&&void 0!==e&&0!=this.hasDoc(e)&&this.addFieldLength(e,t,n)},t.DocumentStore.prototype.getFieldLength=function(e,t){return null===e||void 0===e?0:e in this.docs&&t in this.docInfo[e]?this.docInfo[e][t]:0},t.DocumentStore.prototype.toJSON=function(){return{docs:this.docs,docInfo:this.docInfo,length:this.length,save:this._save}},t.stemmer=function(){var e={ational:"ate",tional:"tion",enci:"ence",anci:"ance",izer:"ize",bli:"ble",alli:"al",entli:"ent",eli:"e",ousli:"ous",ization:"ize",ation:"ate",ator:"ate",alism:"al",iveness:"ive",fulness:"ful",ousness:"ous",aliti:"al",iviti:"ive",biliti:"ble",logi:"log"},t={icate:"ic",ative:"",alize:"al",iciti:"ic",ical:"ic",ful:"",ness:""},n="[^aeiou]",i="[aeiouy]",o=n+"[^aeiouy]*",r=i+"[aeiou]*",s="^("+o+")?"+r+o,u="^("+o+")?"+r+o+"("+r+")?$",a="^("+o+")?"+r+o+r+o,l="^("+o+")?"+i,c=new RegExp(s),d=new RegExp(a),f=new RegExp(u),h=new RegExp(l),p=/^(.+?)(ss|i)es$/,v=/^(.+?)([^s])s$/,g=/^(.+?)eed$/,m=/^(.+?)(ed|ing)$/,y=/.$/,S=/(at|bl|iz)$/,x=new RegExp("([^aeiouylsz])\\1$"),w=new RegExp("^"+o+i+"[^aeiouwxy]$"),I=/^(.+?[^aeiou])y$/,b=/^(.+?)(ational|tional|enci|anci|izer|bli|alli|entli|eli|ousli|ization|ation|ator|alism|iveness|fulness|ousness|aliti|iviti|biliti|logi)$/,E=/^(.+?)(icate|ative|alize|iciti|ical|ful|ness)$/,D=/^(.+?)(al|ance|ence|er|ic|able|ible|ant|ement|ment|ent|ou|ism|ate|iti|ous|ive|ize)$/,F=/^(.+?)(s|t)(ion)$/,_=/^(.+?)e$/,P=/ll$/,k=new RegExp("^"+o+i+"[^aeiouwxy]$"),z=function(n){var i,o,r,s,u,a,l;if(n.length<3)return n;if(r=n.substr(0,1),"y"==r&&(n=r.toUpperCase()+n.substr(1)),s=p,u=v,s.test(n)?n=n.replace(s,"$1$2"):u.test(n)&&(n=n.replace(u,"$1$2")),s=g,u=m,s.test(n)){var z=s.exec(n);s=c,s.test(z[1])&&(s=y,n=n.replace(s,""))}else if(u.test(n)){var z=u.exec(n);i=z[1],u=h,u.test(i)&&(n=i,u=S,a=x,l=w,u.test(n)?n+="e":a.test(n)?(s=y,n=n.replace(s,"")):l.test(n)&&(n+="e"))}if(s=I,s.test(n)){var z=s.exec(n);i=z[1],n=i+"i"}if(s=b,s.test(n)){var z=s.exec(n);i=z[1],o=z[2],s=c,s.test(i)&&(n=i+e[o])}if(s=E,s.test(n)){var z=s.exec(n);i=z[1],o=z[2],s=c,s.test(i)&&(n=i+t[o])}if(s=D,u=F,s.test(n)){var z=s.exec(n);i=z[1],s=d,s.test(i)&&(n=i)}else if(u.test(n)){var z=u.exec(n);i=z[1]+z[2],u=d,u.test(i)&&(n=i)}if(s=_,s.test(n)){var z=s.exec(n);i=z[1],s=d,u=f,a=k,(s.test(i)||u.test(i)&&!a.test(i))&&(n=i)}return s=P,u=d,s.test(n)&&u.test(n)&&(s=y,n=n.replace(s,"")),"y"==r&&(n=r.toLowerCase()+n.substr(1)),n};return z}(),t.Pipeline.registerFunction(t.stemmer,"stemmer"),t.stopWordFilter=function(e){return e&&t.stopWordFilter.stopWords[e]!==!0?e:void 0},t.clearStopWords=function(){t.stopWordFilter.stopWords={}},t.addStopWords=function(e){null!=e&&Array.isArray(e)!==!1&&e.forEach(function(e){t.stopWordFilter.stopWords[e]=!0},this)},t.resetStopWords=function(){t.stopWordFilter.stopWords=t.defaultStopWords},t.defaultStopWords={"":!0,a:!0,able:!0,about:!0,across:!0,after:!0,all:!0,almost:!0,also:!0,am:!0,among:!0,an:!0,and:!0,any:!0,are:!0,as:!0,at:!0,be:!0,because:!0,been:!0,but:!0,by:!0,can:!0,cannot:!0,could:!0,dear:!0,did:!0,"do":!0,does:!0,either:!0,"else":!0,ever:!0,every:!0,"for":!0,from:!0,get:!0,got:!0,had:!0,has:!0,have:!0,he:!0,her:!0,hers:!0,him:!0,his:!0,how:!0,however:!0,i:!0,"if":!0,"in":!0,into:!0,is:!0,it:!0,its:!0,just:!0,least:!0,let:!0,like:!0,likely:!0,may:!0,me:!0,might:!0,most:!0,must:!0,my:!0,neither:!0,no:!0,nor:!0,not:!0,of:!0,off:!0,often:!0,on:!0,only:!0,or:!0,other:!0,our:!0,own:!0,rather:!0,said:!0,say:!0,says:!0,she:!0,should:!0,since:!0,so:!0,some:!0,than:!0,that:!0,the:!0,their:!0,them:!0,then:!0,there:!0,these:!0,they:!0,"this":!0,tis:!0,to:!0,too:!0,twas:!0,us:!0,wants:!0,was:!0,we:!0,were:!0,what:!0,when:!0,where:!0,which:!0,"while":!0,who:!0,whom:!0,why:!0,will:!0,"with":!0,would:!0,yet:!0,you:!0,your:!0},t.stopWordFilter.stopWords=t.defaultStopWords,t.Pipeline.registerFunction(t.stopWordFilter,"stopWordFilter"),t.trimmer=function(e){if(null===e||void 0===e)throw new Error("token should not be undefined");return e.replace(/^\W+/,"").replace(/\W+$/,"")},t.Pipeline.registerFunction(t.trimmer,"trimmer"),t.InvertedIndex=function(){this.root={docs:{},df:0}},t.InvertedIndex.load=function(e){var t=new this;return t.root=e.root,t},t.InvertedIndex.prototype.addToken=function(e,t,n){for(var n=n||this.root,i=0;i<=e.length-1;){var o=e[i];o in n||(n[o]={docs:{},df:0}),i+=1,n=n[o]}var r=t.ref;n.docs[r]?n.docs[r]={tf:t.tf}:(n.docs[r]={tf:t.tf},n.df+=1)},t.InvertedIndex.prototype.hasToken=function(e){if(!e)return!1;for(var t=this.root,n=0;n<e.length;n++){if(!t[e[n]])return!1;t=t[e[n]]}return!0},t.InvertedIndex.prototype.getNode=function(e){if(!e)return null;for(var t=this.root,n=0;n<e.length;n++){if(!t[e[n]])return null;t=t[e[n]]}return t},t.InvertedIndex.prototype.getDocs=function(e){var t=this.getNode(e);return null==t?{}:t.docs},t.InvertedIndex.prototype.getTermFrequency=function(e,t){var n=this.getNode(e);return null==n?0:t in n.docs?n.docs[t].tf:0},t.InvertedIndex.prototype.getDocFreq=function(e){var t=this.getNode(e);return null==t?0:t.df},t.InvertedIndex.prototype.removeToken=function(e,t){if(e){var n=this.getNode(e);null!=n&&t in n.docs&&(delete n.docs[t],n.df-=1)}},t.InvertedIndex.prototype.expandToken=function(e,t,n){if(null==e||""==e)return[];var t=t||[];if(void 0==n&&(n=this.getNode(e),null==n))return t;n.df>0&&t.push(e);for(var i in n)"docs"!==i&&"df"!==i&&this.expandToken(e+i,t,n[i]);return t},t.InvertedIndex.prototype.toJSON=function(){return{root:this.root}},t.Configuration=function(e,n){var e=e||"";if(void 0==n||null==n)throw new Error("fields should not be null");this.config={};var i;try{i=JSON.parse(e),this.buildUserConfig(i,n)}catch(o){t.utils.warn("user configuration parse failed, will use default configuration"),this.buildDefaultConfig(n)}},t.Configuration.prototype.buildDefaultConfig=function(e){this.reset(),e.forEach(function(e){this.config[e]={boost:1,bool:"OR",expand:!1}},this)},t.Configuration.prototype.buildUserConfig=function(e,n){var i="OR",o=!1;if(this.reset(),"bool"in e&&(i=e.bool||i),"expand"in e&&(o=e.expand||o),"fields"in e)for(var r in e.fields)if(n.indexOf(r)>-1){var s=e.fields[r],u=o;void 0!=s.expand&&(u=s.expand),this.config[r]={boost:s.boost||0===s.boost?s.boost:1,bool:s.bool||i,expand:u}}else t.utils.warn("field name in user configuration not found in index instance fields");else this.addAllFields2UserConfig(i,o,n)},t.Configuration.prototype.addAllFields2UserConfig=function(e,t,n){n.forEach(function(n){this.config[n]={boost:1,bool:e,expand:t}},this)},t.Configuration.prototype.get=function(){return this.config},t.Configuration.prototype.reset=function(){this.config={}},lunr.SortedSet=function(){this.length=0,this.elements=[]},lunr.SortedSet.load=function(e){var t=new this;return t.elements=e,t.length=e.length,t},lunr.SortedSet.prototype.add=function(){var e,t;for(e=0;e<arguments.length;e++)t=arguments[e],~this.indexOf(t)||this.elements.splice(this.locationFor(t),0,t);this.length=this.elements.length},lunr.SortedSet.prototype.toArray=function(){return this.elements.slice()},lunr.SortedSet.prototype.map=function(e,t){return this.elements.map(e,t)},lunr.SortedSet.prototype.forEach=function(e,t){return this.elements.forEach(e,t)},lunr.SortedSet.prototype.indexOf=function(e){for(var t=0,n=this.elements.length,i=n-t,o=t+Math.floor(i/2),r=this.elements[o];i>1;){if(r===e)return o;e>r&&(t=o),r>e&&(n=o),i=n-t,o=t+Math.floor(i/2),r=this.elements[o]}return r===e?o:-1},lunr.SortedSet.prototype.locationFor=function(e){for(var t=0,n=this.elements.length,i=n-t,o=t+Math.floor(i/2),r=this.elements[o];i>1;)e>r&&(t=o),r>e&&(n=o),i=n-t,o=t+Math.floor(i/2),r=this.elements[o];return r>e?o:e>r?o+1:void 0},lunr.SortedSet.prototype.intersect=function(e){for(var t=new lunr.SortedSet,n=0,i=0,o=this.length,r=e.length,s=this.elements,u=e.elements;;){if(n>o-1||i>r-1)break;s[n]!==u[i]?s[n]<u[i]?n++:s[n]>u[i]&&i++:(t.add(s[n]),n++,i++)}return t},lunr.SortedSet.prototype.clone=function(){var e=new lunr.SortedSet;return e.elements=this.toArray(),e.length=e.elements.length,e},lunr.SortedSet.prototype.union=function(e){var t,n,i;this.length>=e.length?(t=this,n=e):(t=e,n=this),i=t.clone();for(var o=0,r=n.toArray();o<r.length;o++)i.add(r[o]);return i},lunr.SortedSet.prototype.toJSON=function(){return this.toArray()},function(e,t){"function"==typeof define&&define.amd?define(t):"object"==typeof exports?module.exports=t():e.elasticlunr=t()}(this,function(){return t})}();

/** pdoc search index */const docs = [{"fullname": "duckdb", "modulename": "duckdb", "kind": "module", "doc": "The DuckDB Python Package.\n\nThis module re-exports the DuckDB C++ extension (<code>_duckdb</code>) and provides DuckDB's public API.\n\nNote:\n\n<ul>\n<li>Some symbols exposed here are implementation details of DuckDB's C++ engine.</li>\n<li>They are kept for backwards compatibility but are not considered stable API.</li>\n<li>Future versions may move them into submodules with deprecation warnings.</li>\n</ul>\n"}, {"fullname": "duckdb.BinaryValue", "modulename": "duckdb", "qualname": "BinaryValue", "kind": "class", "doc": "\n", "bases": "duckdb.value.constant.Value"}, {"fullname": "duckdb.BinaryValue.__init__", "modulename": "duckdb", "qualname": "BinaryValue.__init__", "kind": "function", "doc": "\n", "signature": "(object: Any)"}, {"fullname": "duckdb.BinderException", "modulename": "duckdb", "qualname": "BinderException", "kind": "class", "doc": "Common base class for all non-exit exceptions.\n", "bases": "_duckdb.ProgrammingError"}, {"fullname": "duckdb.BitValue", "modulename": "duckdb", "qualname": "BitValue", "kind": "class", "doc": "\n", "bases": "duckdb.value.constant.Value"}, {"fullname": "duckdb.BitValue.__init__", "modulename": "duckdb", "qualname": "BitValue.__init__", "kind": "function", "doc": "\n", "signature": "(object: Any)"}, {"fullname": "duckdb.BlobValue", "modulename": "duckdb", "qualname": "BlobValue", "kind": "class", "doc": "\n", "bases": "duckdb.value.constant.Value"}, {"fullname": "duckdb.BlobValue.__init__", "modulename": "duckdb", "qualname": "BlobValue.__init__", "kind": "function", "doc": "\n", "signature": "(object: Any)"}, {"fullname": "duckdb.BooleanValue", "modulename": "duckdb", "qualname": "BooleanValue", "kind": "class", "doc": "\n", "bases": "duckdb.value.constant.Value"}, {"fullname": "duckdb.BooleanValue.__init__", "modulename": "duckdb", "qualname": "BooleanValue.__init__", "kind": "function", "doc": "\n", "signature": "(object: Any)"}, {"fullname": "duckdb.CSVLineTerminator", "modulename": "duckdb", "qualname": "CSVLineTerminator", "kind": "class", "doc": "Members:\n\nLINE_FEED\n\nCARRIAGE_RETURN_LINE_FEED\n", "bases": "pybind11_builtins.pybind11_object"}, {"fullname": "duckdb.CSVLineTerminator.__init__", "modulename": "duckdb", "qualname": "CSVLineTerminator.__init__", "kind": "function", "doc": "__init__(self: _duckdb.CSVLineTerminator, value: typing.SupportsInt) -> None\n", "signature": "()"}, {"fullname": "duckdb.CSVLineTerminator.name", "modulename": "duckdb", "qualname": "CSVLineTerminator.name", "kind": "variable", "doc": "name(self: object, /) -> str\n"}, {"fullname": "duckdb.CSVLineTerminator.value", "modulename": "duckdb", "qualname": "CSVLineTerminator.value", "kind": "variable", "doc": "(arg0: _duckdb.CSVLineTerminator) -> int\n"}, {"fullname": "duckdb.CSVLineTerminator.LINE_FEED", "modulename": "duckdb", "qualname": "CSVLineTerminator.LINE_FEED", "kind": "variable", "doc": "\n", "default_value": "<CSVLineTerminator.LINE_FEED: 0>"}, {"fullname": "duckdb.CSVLineTerminator.CARRIAGE_RETURN_LINE_FEED", "modulename": "duckdb", "qualname": "CSVLineTerminator.CARRIAGE_RETURN_LINE_FEED", "kind": "variable", "doc": "\n", "default_value": "<CSVLineTerminator.CARRIAGE_RETURN_LINE_FEED: 1>"}, {"fullname": "duckdb.CaseExpression", "modulename": "duckdb", "qualname": "CaseExpression", "kind": "function", "doc": "CaseExpression(condition: _duckdb.Expression, value: _duckdb.Expression) -> _duckdb.Expression\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.CatalogException", "modulename": "duckdb", "qualname": "CatalogException", "kind": "class", "doc": "Common base class for all non-exit exceptions.\n", "bases": "_duckdb.ProgrammingError"}, {"fullname": "duckdb.CoalesceOperator", "modulename": "duckdb", "qualname": "CoalesceOperator", "kind": "function", "doc": "CoalesceOperator(*args) -> _duckdb.Expression\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.ColumnExpression", "modulename": "duckdb", "qualname": "ColumnExpression", "kind": "function", "doc": "ColumnExpression(*args) -> _duckdb.Expression\n\nCreate a column reference from the provided column name\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.ConnectionException", "modulename": "duckdb", "qualname": "ConnectionException", "kind": "class", "doc": "Common base class for all non-exit exceptions.\n", "bases": "_duckdb.OperationalError"}, {"fullname": "duckdb.ConstantExpression", "modulename": "duckdb", "qualname": "ConstantExpression", "kind": "function", "doc": "ConstantExpression(value: object) -> _duckdb.Expression\n\nCreate a constant expression from the provided value\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.ConstraintException", "modulename": "duckdb", "qualname": "ConstraintException", "kind": "class", "doc": "Common base class for all non-exit exceptions.\n", "bases": "_duckdb.IntegrityError"}, {"fullname": "duckdb.ConversionException", "modulename": "duckdb", "qualname": "ConversionException", "kind": "class", "doc": "Common base class for all non-exit exceptions.\n", "bases": "_duckdb.DataError"}, {"fullname": "duckdb.DataError", "modulename": "duckdb", "qualname": "DataError", "kind": "class", "doc": "Common base class for all non-exit exceptions.\n", "bases": "_duckdb.DatabaseError"}, {"fullname": "duckdb.DatabaseError", "modulename": "duckdb", "qualname": "DatabaseError", "kind": "class", "doc": "Common base class for all non-exit exceptions.\n", "bases": "_duckdb.Error"}, {"fullname": "duckdb.DateValue", "modulename": "duckdb", "qualname": "DateValue", "kind": "class", "doc": "\n", "bases": "duckdb.value.constant.Value"}, {"fullname": "duckdb.DateValue.__init__", "modulename": "duckdb", "qualname": "DateValue.__init__", "kind": "function", "doc": "\n", "signature": "(object: Any)"}, {"fullname": "duckdb.DecimalValue", "modulename": "duckdb", "qualname": "DecimalValue", "kind": "class", "doc": "\n", "bases": "duckdb.value.constant.Value"}, {"fullname": "duckdb.DecimalValue.__init__", "modulename": "duckdb", "qualname": "DecimalValue.__init__", "kind": "function", "doc": "\n", "signature": "(object: Any, width: int, scale: int)"}, {"fullname": "duckdb.DefaultExpression", "modulename": "duckdb", "qualname": "DefaultExpression", "kind": "function", "doc": "DefaultExpression() -> _duckdb.Expression\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DependencyException", "modulename": "duckdb", "qualname": "DependencyException", "kind": "class", "doc": "Common base class for all non-exit exceptions.\n", "bases": "_duckdb.DatabaseError"}, {"fullname": "duckdb.DoubleValue", "modulename": "duckdb", "qualname": "DoubleValue", "kind": "class", "doc": "\n", "bases": "duckdb.value.constant.Value"}, {"fullname": "duckdb.DoubleValue.__init__", "modulename": "duckdb", "qualname": "DoubleValue.__init__", "kind": "function", "doc": "\n", "signature": "(object: Any)"}, {"fullname": "duckdb.DuckDBPyConnection", "modulename": "duckdb", "qualname": "DuckDBPyConnection", "kind": "class", "doc": "\n", "bases": "pybind11_builtins.pybind11_object"}, {"fullname": "duckdb.DuckDBPyConnection.__init__", "modulename": "duckdb", "qualname": "DuckDBPyConnection.__init__", "kind": "function", "doc": "\n", "signature": "(*args, **kwargs)"}, {"fullname": "duckdb.DuckDBPyConnection.cursor", "modulename": "duckdb", "qualname": "DuckDBPyConnection.cursor", "kind": "function", "doc": "cursor(self: _duckdb.DuckDBPyConnection) -> _duckdb.DuckDBPyConnection\n\nCreate a duplicate of the current connection\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyConnection.register_filesystem", "modulename": "duckdb", "qualname": "DuckDBPyConnection.register_filesystem", "kind": "function", "doc": "register_filesystem(self: _duckdb.DuckDBPyConnection, filesystem: fsspec.AbstractFileSystem) -> None\n\nRegister a fsspec compliant filesystem\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyConnection.unregister_filesystem", "modulename": "duckdb", "qualname": "DuckDBPyConnection.unregister_filesystem", "kind": "function", "doc": "unregister_filesystem(self: _duckdb.DuckDBPyConnection, name: str) -> None\n\nUnregister a filesystem\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyConnection.list_filesystems", "modulename": "duckdb", "qualname": "DuckDBPyConnection.list_filesystems", "kind": "function", "doc": "list_filesystems(self: _duckdb.DuckDBPyConnection) -> list\n\nList registered filesystems, including builtin ones\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyConnection.filesystem_is_registered", "modulename": "duckdb", "qualname": "DuckDBPyConnection.filesystem_is_registered", "kind": "function", "doc": "filesystem_is_registered(self: _duckdb.DuckDBPyConnection, name: str) -> bool\n\nCheck if a filesystem with the provided name is currently registered\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyConnection.create_function", "modulename": "duckdb", "qualname": "DuckDBPyConnection.create_function", "kind": "function", "doc": "create_function(self: _duckdb.DuckDBPyConnection, name: str, function: collections.abc.Callable, parameters: object = None, return_type: _duckdb._sqltypes.DuckDBPyType = None, *, type: _duckdb._func.PythonUDFType = <PythonUDFType.NATIVE: 0>, null_handling: _duckdb._func.FunctionNullHandling = <FunctionNullHandling.DEFAULT: 0>, exception_handling: _duckdb.PythonExceptionHandling = <PythonExceptionHandling.DEFAULT: 0>, side_effects: bool = False) -> _duckdb.DuckDBPyConnection\n\nCreate a DuckDB function out of the passing in Python function so it can be used in queries\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyConnection.remove_function", "modulename": "duckdb", "qualname": "DuckDBPyConnection.remove_function", "kind": "function", "doc": "remove_function(self: _duckdb.DuckDBPyConnection, name: str) -> _duckdb.DuckDBPyConnection\n\nRemove a previously created function\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyConnection.sqltype", "modulename": "duckdb", "qualname": "DuckDBPyConnection.sqltype", "kind": "function", "doc": "sqltype(self: _duckdb.DuckDBPyConnection, type_str: str) -> _duckdb._sqltypes.DuckDBPyType\n\nCreate a type object by parsing the 'type_str' string\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyConnection.dtype", "modulename": "duckdb", "qualname": "DuckDBPyConnection.dtype", "kind": "function", "doc": "dtype(self: _duckdb.DuckDBPyConnection, type_str: str) -> _duckdb._sqltypes.DuckDBPyType\n\nCreate a type object by parsing the 'type_str' string\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyConnection.type", "modulename": "duckdb", "qualname": "DuckDBPyConnection.type", "kind": "function", "doc": "type(self: _duckdb.DuckDBPyConnection, type_str: str) -> _duckdb._sqltypes.DuckDBPyType\n\nCreate a type object by parsing the 'type_str' string\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyConnection.array_type", "modulename": "duckdb", "qualname": "DuckDBPyConnection.array_type", "kind": "function", "doc": "array_type(self: _duckdb.DuckDBPyConnection, type: _duckdb._sqltypes.DuckDBPyType, size: typing.SupportsInt) -> _duckdb._sqltypes.DuckDBPyType\n\nCreate an array type object of 'type'\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyConnection.list_type", "modulename": "duckdb", "qualname": "DuckDBPyConnection.list_type", "kind": "function", "doc": "list_type(self: _duckdb.DuckDBPyConnection, type: _duckdb._sqltypes.DuckDBPyType) -> _duckdb._sqltypes.DuckDBPyType\n\nCreate a list type object of 'type'\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyConnection.union_type", "modulename": "duckdb", "qualname": "DuckDBPyConnection.union_type", "kind": "function", "doc": "union_type(self: _duckdb.DuckDBPyConnection, members: object) -> _duckdb._sqltypes.DuckDBPyType\n\nCreate a union type object from 'members'\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyConnection.string_type", "modulename": "duckdb", "qualname": "DuckDBPyConnection.string_type", "kind": "function", "doc": "string_type(self: _duckdb.DuckDBPyConnection, collation: str = '') -> _duckdb._sqltypes.DuckDBPyType\n\nCreate a string type with an optional collation\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyConnection.enum_type", "modulename": "duckdb", "qualname": "DuckDBPyConnection.enum_type", "kind": "function", "doc": "enum_type(self: _duckdb.DuckDBPyConnection, name: str, type: _duckdb._sqltypes.DuckDBPyType, values: list) -> _duckdb._sqltypes.DuckDBPyType\n\nCreate an enum type of underlying 'type', consisting of the list of 'values'\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyConnection.decimal_type", "modulename": "duckdb", "qualname": "DuckDBPyConnection.decimal_type", "kind": "function", "doc": "decimal_type(self: _duckdb.DuckDBPyConnection, width: typing.SupportsInt, scale: typing.SupportsInt) -> _duckdb._sqltypes.DuckDBPyType\n\nCreate a decimal type with 'width' and 'scale'\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyConnection.struct_type", "modulename": "duckdb", "qualname": "DuckDBPyConnection.struct_type", "kind": "function", "doc": "struct_type(self: _duckdb.DuckDBPyConnection, fields: object) -> _duckdb._sqltypes.DuckDBPyType\n\nCreate a struct type object from 'fields'\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyConnection.row_type", "modulename": "duckdb", "qualname": "DuckDBPyConnection.row_type", "kind": "function", "doc": "row_type(self: _duckdb.DuckDBPyConnection, fields: object) -> _duckdb._sqltypes.DuckDBPyType\n\nCreate a struct type object from 'fields'\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyConnection.map_type", "modulename": "duckdb", "qualname": "DuckDBPyConnection.map_type", "kind": "function", "doc": "map_type(self: _duckdb.DuckDBPyConnection, key: _duckdb._sqltypes.DuckDBPyType, value: _duckdb._sqltypes.DuckDBPyType) -> _duckdb._sqltypes.DuckDBPyType\n\nCreate a map type object from 'key_type' and 'value_type'\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyConnection.duplicate", "modulename": "duckdb", "qualname": "DuckDBPyConnection.duplicate", "kind": "function", "doc": "duplicate(self: _duckdb.DuckDBPyConnection) -> _duckdb.DuckDBPyConnection\n\nCreate a duplicate of the current connection\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyConnection.execute", "modulename": "duckdb", "qualname": "DuckDBPyConnection.execute", "kind": "function", "doc": "execute(self: _duckdb.DuckDBPyConnection, query: object, parameters: object = None) -> _duckdb.DuckDBPyConnection\n\nExecute the given SQL query, optionally using prepared statements with parameters set\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyConnection.executemany", "modulename": "duckdb", "qualname": "DuckDBPyConnection.executemany", "kind": "function", "doc": "executemany(self: _duckdb.DuckDBPyConnection, query: object, parameters: object = None) -> _duckdb.DuckDBPyConnection\n\nExecute the given prepared statement multiple times using the list of parameter sets in parameters\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyConnection.close", "modulename": "duckdb", "qualname": "DuckDBPyConnection.close", "kind": "function", "doc": "close(self: _duckdb.DuckDBPyConnection) -> None\n\nClose the connection\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyConnection.interrupt", "modulename": "duckdb", "qualname": "DuckDBPyConnection.interrupt", "kind": "function", "doc": "interrupt(self: _duckdb.DuckDBPyConnection) -> None\n\nInterrupt pending operations\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyConnection.query_progress", "modulename": "duckdb", "qualname": "DuckDBPyConnection.query_progress", "kind": "function", "doc": "query_progress(self: _duckdb.DuckDBPyConnection) -> float\n\nQuery progress of pending operation\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyConnection.fetchone", "modulename": "duckdb", "qualname": "DuckDBPyConnection.fetchone", "kind": "function", "doc": "fetchone(self: _duckdb.DuckDBPyConnection) -> typing.Optional[tuple]\n\nFetch a single row from a result following execute\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyConnection.fetchmany", "modulename": "duckdb", "qualname": "DuckDBPyConnection.fetchmany", "kind": "function", "doc": "fetchmany(self: _duckdb.DuckDBPyConnection, size: typing.SupportsInt = 1) -> list\n\nFetch the next set of rows from a result following execute\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyConnection.fetchall", "modulename": "duckdb", "qualname": "DuckDBPyConnection.fetchall", "kind": "function", "doc": "fetchall(self: _duckdb.DuckDBPyConnection) -> list\n\nFetch all rows from a result following execute\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyConnection.fetchnumpy", "modulename": "duckdb", "qualname": "DuckDBPyConnection.fetchnumpy", "kind": "function", "doc": "fetchnumpy(self: _duckdb.DuckDBPyConnection) -> dict\n\nFetch a result as list of NumPy arrays following execute\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyConnection.fetchdf", "modulename": "duckdb", "qualname": "DuckDBPyConnection.fetchdf", "kind": "function", "doc": "fetchdf(self: _duckdb.DuckDBPyConnection, *, date_as_object: bool = False) -> pandas.DataFrame\n\nFetch a result as DataFrame following execute()\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyConnection.fetch_df", "modulename": "duckdb", "qualname": "DuckDBPyConnection.fetch_df", "kind": "function", "doc": "fetch_df(self: _duckdb.DuckDBPyConnection, *, date_as_object: bool = False) -> pandas.DataFrame\n\nFetch a result as DataFrame following execute()\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyConnection.df", "modulename": "duckdb", "qualname": "DuckDBPyConnection.df", "kind": "function", "doc": "df(self: _duckdb.DuckDBPyConnection, *, date_as_object: bool = False) -> pandas.DataFrame\n\nFetch a result as DataFrame following execute()\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyConnection.fetch_df_chunk", "modulename": "duckdb", "qualname": "DuckDBPyConnection.fetch_df_chunk", "kind": "function", "doc": "fetch_df_chunk(self: _duckdb.DuckDBPyConnection, vectors_per_chunk: typing.SupportsInt = 1, *, date_as_object: bool = False) -> pandas.DataFrame\n\nFetch a chunk of the result as DataFrame following execute()\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyConnection.pl", "modulename": "duckdb", "qualname": "DuckDBPyConnection.pl", "kind": "function", "doc": "pl(self: _duckdb.DuckDBPyConnection, rows_per_batch: typing.SupportsInt = 1000000, *, lazy: bool = False) -> duckdb::PolarsDataFrame\n\nFetch a result as Polars DataFrame following execute()\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyConnection.fetch_arrow_table", "modulename": "duckdb", "qualname": "DuckDBPyConnection.fetch_arrow_table", "kind": "function", "doc": "fetch_arrow_table(self: _duckdb.DuckDBPyConnection, rows_per_batch: typing.SupportsInt = 1000000) -> pyarrow.lib.Table\n\nFetch a result as Arrow table following execute()\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyConnection.fetch_record_batch", "modulename": "duckdb", "qualname": "DuckDBPyConnection.fetch_record_batch", "kind": "function", "doc": "fetch_record_batch(self: _duckdb.DuckDBPyConnection, rows_per_batch: typing.SupportsInt = 1000000) -> pyarrow.lib.RecordBatchReader\n\nFetch an Arrow RecordBatchReader following execute()\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyConnection.arrow", "modulename": "duckdb", "qualname": "DuckDBPyConnection.arrow", "kind": "function", "doc": "arrow(self: _duckdb.DuckDBPyConnection, rows_per_batch: typing.SupportsInt = 1000000) -> pyarrow.lib.RecordBatchReader\n\nFetch an Arrow RecordBatchReader following execute()\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyConnection.torch", "modulename": "duckdb", "qualname": "DuckDBPyConnection.torch", "kind": "function", "doc": "torch(self: _duckdb.DuckDBPyConnection) -> dict\n\nFetch a result as dict of PyTorch Tensors following execute()\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyConnection.tf", "modulename": "duckdb", "qualname": "DuckDBPyConnection.tf", "kind": "function", "doc": "tf(self: _duckdb.DuckDBPyConnection) -> dict\n\nFetch a result as dict of TensorFlow Tensors following execute()\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyConnection.begin", "modulename": "duckdb", "qualname": "DuckDBPyConnection.begin", "kind": "function", "doc": "begin(self: _duckdb.DuckDBPyConnection) -> _duckdb.DuckDBPyConnection\n\nStart a new transaction\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyConnection.commit", "modulename": "duckdb", "qualname": "DuckDBPyConnection.commit", "kind": "function", "doc": "commit(self: _duckdb.DuckDBPyConnection) -> _duckdb.DuckDBPyConnection\n\nCommit changes performed within a transaction\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyConnection.rollback", "modulename": "duckdb", "qualname": "DuckDBPyConnection.rollback", "kind": "function", "doc": "rollback(self: _duckdb.DuckDBPyConnection) -> _duckdb.DuckDBPyConnection\n\nRoll back changes performed within a transaction\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyConnection.checkpoint", "modulename": "duckdb", "qualname": "DuckDBPyConnection.checkpoint", "kind": "function", "doc": "checkpoint(self: _duckdb.DuckDBPyConnection) -> _duckdb.DuckDBPyConnection\n\nSynchronizes data in the write-ahead log (WAL) to the database data file (no-op for in-memory connections)\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyConnection.append", "modulename": "duckdb", "qualname": "DuckDBPyConnection.append", "kind": "function", "doc": "append(self: _duckdb.DuckDBPyConnection, table_name: str, df: pandas.DataFrame, *, by_name: bool = False) -> _duckdb.DuckDBPyConnection\n\nAppend the passed DataFrame to the named table\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyConnection.register", "modulename": "duckdb", "qualname": "DuckDBPyConnection.register", "kind": "function", "doc": "register(self: _duckdb.DuckDBPyConnection, view_name: str, python_object: object) -> _duckdb.DuckDBPyConnection\n\nRegister the passed Python Object value for querying with a view\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyConnection.unregister", "modulename": "duckdb", "qualname": "DuckDBPyConnection.unregister", "kind": "function", "doc": "unregister(self: _duckdb.DuckDBPyConnection, view_name: str) -> _duckdb.DuckDBPyConnection\n\nUnregister the view name\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyConnection.table", "modulename": "duckdb", "qualname": "DuckDBPyConnection.table", "kind": "function", "doc": "table(self: _duckdb.DuckDBPyConnection, table_name: str) -> _duckdb.DuckDBPyRelation\n\nCreate a relation object for the named table\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyConnection.view", "modulename": "duckdb", "qualname": "DuckDBPyConnection.view", "kind": "function", "doc": "view(self: _duckdb.DuckDBPyConnection, view_name: str) -> _duckdb.DuckDBPyRelation\n\nCreate a relation object for the named view\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyConnection.values", "modulename": "duckdb", "qualname": "DuckDBPyConnection.values", "kind": "function", "doc": "values(self: _duckdb.DuckDBPyConnection, *args) -> _duckdb.DuckDBPyRelation\n\nCreate a relation object from the passed values\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyConnection.table_function", "modulename": "duckdb", "qualname": "DuckDBPyConnection.table_function", "kind": "function", "doc": "table_function(self: _duckdb.DuckDBPyConnection, name: str, parameters: object = None) -> _duckdb.DuckDBPyRelation\n\nCreate a relation object from the named table function with given parameters\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyConnection.read_json", "modulename": "duckdb", "qualname": "DuckDBPyConnection.read_json", "kind": "function", "doc": "read_json(self: _duckdb.DuckDBPyConnection, path_or_buffer: object, *, columns: typing.Optional[object] = None, sample_size: typing.Optional[object] = None, maximum_depth: typing.Optional[object] = None, records: typing.Optional[str] = None, format: typing.Optional[str] = None, date_format: typing.Optional[object] = None, timestamp_format: typing.Optional[object] = None, compression: typing.Optional[object] = None, maximum_object_size: typing.Optional[object] = None, ignore_errors: typing.Optional[object] = None, convert_strings_to_integers: typing.Optional[object] = None, field_appearance_threshold: typing.Optional[object] = None, map_inference_threshold: typing.Optional[object] = None, maximum_sample_files: typing.Optional[object] = None, filename: typing.Optional[object] = None, hive_partitioning: typing.Optional[object] = None, union_by_name: typing.Optional[object] = None, hive_types: typing.Optional[object] = None, hive_types_autocast: typing.Optional[object] = None) -> _duckdb.DuckDBPyRelation\n\nCreate a relation object from the JSON file in 'name'\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyConnection.extract_statements", "modulename": "duckdb", "qualname": "DuckDBPyConnection.extract_statements", "kind": "function", "doc": "extract_statements(self: _duckdb.DuckDBPyConnection, query: str) -> list\n\nParse the query string and extract the Statement object(s) produced\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyConnection.sql", "modulename": "duckdb", "qualname": "DuckDBPyConnection.sql", "kind": "function", "doc": "sql(self: _duckdb.DuckDBPyConnection, query: object, *, alias: str = '', params: object = None) -> _duckdb.DuckDBPyRelation\n\nRun a SQL query. If it is a SELECT statement, create a relation object from the given SQL query, otherwise run the query as-is.\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyConnection.query", "modulename": "duckdb", "qualname": "DuckDBPyConnection.query", "kind": "function", "doc": "query(self: _duckdb.DuckDBPyConnection, query: object, *, alias: str = '', params: object = None) -> _duckdb.DuckDBPyRelation\n\nRun a SQL query. If it is a SELECT statement, create a relation object from the given SQL query, otherwise run the query as-is.\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyConnection.from_query", "modulename": "duckdb", "qualname": "DuckDBPyConnection.from_query", "kind": "function", "doc": "from_query(self: _duckdb.DuckDBPyConnection, query: object, *, alias: str = '', params: object = None) -> _duckdb.DuckDBPyRelation\n\nRun a SQL query. If it is a SELECT statement, create a relation object from the given SQL query, otherwise run the query as-is.\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyConnection.read_csv", "modulename": "duckdb", "qualname": "DuckDBPyConnection.read_csv", "kind": "function", "doc": "read_csv(self: _duckdb.DuckDBPyConnection, path_or_buffer: object, **kwargs) -> _duckdb.DuckDBPyRelation\n\nCreate a relation object from the CSV file in 'name'\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyConnection.from_csv_auto", "modulename": "duckdb", "qualname": "DuckDBPyConnection.from_csv_auto", "kind": "function", "doc": "from_csv_auto(self: _duckdb.DuckDBPyConnection, path_or_buffer: object, **kwargs) -> _duckdb.DuckDBPyRelation\n\nCreate a relation object from the CSV file in 'name'\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyConnection.from_df", "modulename": "duckdb", "qualname": "DuckDBPyConnection.from_df", "kind": "function", "doc": "from_df(self: _duckdb.DuckDBPyConnection, df: pandas.DataFrame) -> _duckdb.DuckDBPyRelation\n\nCreate a relation object from the DataFrame in df\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyConnection.from_arrow", "modulename": "duckdb", "qualname": "DuckDBPyConnection.from_arrow", "kind": "function", "doc": "from_arrow(self: _duckdb.DuckDBPyConnection, arrow_object: object) -> _duckdb.DuckDBPyRelation\n\nCreate a relation object from an Arrow object\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyConnection.from_parquet", "modulename": "duckdb", "qualname": "DuckDBPyConnection.from_parquet", "kind": "function", "doc": "from_parquet(args, *kwargs)\nOverloaded function.\n\n<ol>\n<li>from_parquet(self: _duckdb.DuckDBPyConnection, file_glob: str, binary_as_string: bool = False, *, file_row_number: bool = False, filename: bool = False, hive_partitioning: bool = False, union_by_name: bool = False, compression: object = None) -> _duckdb.DuckDBPyRelation</li>\n</ol>\n\nCreate a relation object from the Parquet files in file_glob\n\n<ol start=\"2\">\n<li>from_parquet(self: _duckdb.DuckDBPyConnection, file_globs: collections.abc.Sequence[str], binary_as_string: bool = False, *, file_row_number: bool = False, filename: bool = False, hive_partitioning: bool = False, union_by_name: bool = False, compression: object = None) -> _duckdb.DuckDBPyRelation</li>\n</ol>\n\nCreate a relation object from the Parquet files in file_globs\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyConnection.read_parquet", "modulename": "duckdb", "qualname": "DuckDBPyConnection.read_parquet", "kind": "function", "doc": "read_parquet(args, *kwargs)\nOverloaded function.\n\n<ol>\n<li>read_parquet(self: _duckdb.DuckDBPyConnection, file_glob: str, binary_as_string: bool = False, *, file_row_number: bool = False, filename: bool = False, hive_partitioning: bool = False, union_by_name: bool = False, compression: object = None) -> _duckdb.DuckDBPyRelation</li>\n</ol>\n\nCreate a relation object from the Parquet files in file_glob\n\n<ol start=\"2\">\n<li>read_parquet(self: _duckdb.DuckDBPyConnection, file_globs: collections.abc.Sequence[str], binary_as_string: bool = False, *, file_row_number: bool = False, filename: bool = False, hive_partitioning: bool = False, union_by_name: bool = False, compression: object = None) -> _duckdb.DuckDBPyRelation</li>\n</ol>\n\nCreate a relation object from the Parquet files in file_globs\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyConnection.get_table_names", "modulename": "duckdb", "qualname": "DuckDBPyConnection.get_table_names", "kind": "function", "doc": "get_table_names(self: _duckdb.DuckDBPyConnection, query: str, *, qualified: bool = False) -> set[str]\n\nExtract the required table names from a query\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyConnection.install_extension", "modulename": "duckdb", "qualname": "DuckDBPyConnection.install_extension", "kind": "function", "doc": "install_extension(self: _duckdb.DuckDBPyConnection, extension: str, *, force_install: bool = False, repository: object = None, repository_url: object = None, version: object = None) -> None\n\nInstall an extension by name, with an optional version and/or repository to get the extension from\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyConnection.load_extension", "modulename": "duckdb", "qualname": "DuckDBPyConnection.load_extension", "kind": "function", "doc": "load_extension(self: _duckdb.DuckDBPyConnection, extension: str) -> None\n\nLoad an installed extension\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyConnection.description", "modulename": "duckdb", "qualname": "DuckDBPyConnection.description", "kind": "variable", "doc": "(arg0: _duckdb.DuckDBPyConnection) -> typing.Optional[list]\n"}, {"fullname": "duckdb.DuckDBPyConnection.rowcount", "modulename": "duckdb", "qualname": "DuckDBPyConnection.rowcount", "kind": "variable", "doc": "(arg0: _duckdb.DuckDBPyConnection) -> int\n"}, {"fullname": "duckdb.DuckDBPyRelation", "modulename": "duckdb", "qualname": "DuckDBPyRelation", "kind": "class", "doc": "\n", "bases": "pybind11_builtins.pybind11_object"}, {"fullname": "duckdb.DuckDBPyRelation.__init__", "modulename": "duckdb", "qualname": "DuckDBPyRelation.__init__", "kind": "function", "doc": "\n", "signature": "(*args, **kwargs)"}, {"fullname": "duckdb.DuckDBPyRelation.type", "modulename": "duckdb", "qualname": "DuckDBPyRelation.type", "kind": "variable", "doc": "(arg0: _duckdb.DuckDBPyRelation) -> str\n"}, {"fullname": "duckdb.DuckDBPyRelation.columns", "modulename": "duckdb", "qualname": "DuckDBPyRelation.columns", "kind": "variable", "doc": "(arg0: _duckdb.DuckDBPyRelation) -> list\n"}, {"fullname": "duckdb.DuckDBPyRelation.types", "modulename": "duckdb", "qualname": "DuckDBPyRelation.types", "kind": "variable", "doc": "(arg0: _duckdb.DuckDBPyRelation) -> list\n"}, {"fullname": "duckdb.DuckDBPyRelation.dtypes", "modulename": "duckdb", "qualname": "DuckDBPyRelation.dtypes", "kind": "variable", "doc": "(arg0: _duckdb.DuckDBPyRelation) -> list\n"}, {"fullname": "duckdb.DuckDBPyRelation.description", "modulename": "duckdb", "qualname": "DuckDBPyRelation.description", "kind": "variable", "doc": "(arg0: _duckdb.DuckDBPyRelation) -> list\n"}, {"fullname": "duckdb.DuckDBPyRelation.alias", "modulename": "duckdb", "qualname": "DuckDBPyRelation.alias", "kind": "variable", "doc": "(arg0: _duckdb.DuckDBPyRelation) -> str\n"}, {"fullname": "duckdb.DuckDBPyRelation.shape", "modulename": "duckdb", "qualname": "DuckDBPyRelation.shape", "kind": "variable", "doc": "(arg0: _duckdb.DuckDBPyRelation) -> tuple\n"}, {"fullname": "duckdb.DuckDBPyRelation.any_value", "modulename": "duckdb", "qualname": "DuckDBPyRelation.any_value", "kind": "function", "doc": "any_value(self: _duckdb.DuckDBPyRelation, column: str, groups: str = '', window_spec: str = '', projected_columns: str = '') -> _duckdb.DuckDBPyRelation\n\nReturns the first non-null value from a given column\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyRelation.arg_max", "modulename": "duckdb", "qualname": "DuckDBPyRelation.arg_max", "kind": "function", "doc": "arg_max(self: _duckdb.DuckDBPyRelation, arg_column: str, value_column: str, groups: str = '', window_spec: str = '', projected_columns: str = '') -> _duckdb.DuckDBPyRelation\n\nFinds the row with the maximum value for a value column and returns the value of that row for an argument column\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyRelation.arg_min", "modulename": "duckdb", "qualname": "DuckDBPyRelation.arg_min", "kind": "function", "doc": "arg_min(self: _duckdb.DuckDBPyRelation, arg_column: str, value_column: str, groups: str = '', window_spec: str = '', projected_columns: str = '') -> _duckdb.DuckDBPyRelation\n\nFinds the row with the minimum value for a value column and returns the value of that row for an argument column\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyRelation.avg", "modulename": "duckdb", "qualname": "DuckDBPyRelation.avg", "kind": "function", "doc": "avg(self: _duckdb.DuckDBPyRelation, column: str, groups: str = '', window_spec: str = '', projected_columns: str = '') -> _duckdb.DuckDBPyRelation\n\nComputes the average on a given column\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyRelation.mean", "modulename": "duckdb", "qualname": "DuckDBPyRelation.mean", "kind": "function", "doc": "mean(self: _duckdb.DuckDBPyRelation, column: str, groups: str = '', window_spec: str = '', projected_columns: str = '') -> _duckdb.DuckDBPyRelation\n\nComputes the average on a given column\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyRelation.bit_and", "modulename": "duckdb", "qualname": "DuckDBPyRelation.bit_and", "kind": "function", "doc": "bit_and(self: _duckdb.DuckDBPyRelation, column: str, groups: str = '', window_spec: str = '', projected_columns: str = '') -> _duckdb.DuckDBPyRelation\n\nComputes the bitwise AND of all bits present in a given column\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyRelation.bit_or", "modulename": "duckdb", "qualname": "DuckDBPyRelation.bit_or", "kind": "function", "doc": "bit_or(self: _duckdb.DuckDBPyRelation, column: str, groups: str = '', window_spec: str = '', projected_columns: str = '') -> _duckdb.DuckDBPyRelation\n\nComputes the bitwise OR of all bits present in a given column\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyRelation.bit_xor", "modulename": "duckdb", "qualname": "DuckDBPyRelation.bit_xor", "kind": "function", "doc": "bit_xor(self: _duckdb.DuckDBPyRelation, column: str, groups: str = '', window_spec: str = '', projected_columns: str = '') -> _duckdb.DuckDBPyRelation\n\nComputes the bitwise XOR of all bits present in a given column\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyRelation.bitstring_agg", "modulename": "duckdb", "qualname": "DuckDBPyRelation.bitstring_agg", "kind": "function", "doc": "bitstring_agg(self: _duckdb.DuckDBPyRelation, column: str, min: typing.Optional[object] = None, max: typing.Optional[object] = None, groups: str = '', window_spec: str = '', projected_columns: str = '') -> _duckdb.DuckDBPyRelation\n\nComputes a bitstring with bits set for each distinct value in a given column\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyRelation.bool_and", "modulename": "duckdb", "qualname": "DuckDBPyRelation.bool_and", "kind": "function", "doc": "bool_and(self: _duckdb.DuckDBPyRelation, column: str, groups: str = '', window_spec: str = '', projected_columns: str = '') -> _duckdb.DuckDBPyRelation\n\nComputes the logical AND of all values present in a given column\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyRelation.bool_or", "modulename": "duckdb", "qualname": "DuckDBPyRelation.bool_or", "kind": "function", "doc": "bool_or(self: _duckdb.DuckDBPyRelation, column: str, groups: str = '', window_spec: str = '', projected_columns: str = '') -> _duckdb.DuckDBPyRelation\n\nComputes the logical OR of all values present in a given column\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyRelation.count", "modulename": "duckdb", "qualname": "DuckDBPyRelation.count", "kind": "function", "doc": "count(self: _duckdb.DuckDBPyRelation, column: str, groups: str = '', window_spec: str = '', projected_columns: str = '') -> _duckdb.DuckDBPyRelation\n\nComputes the number of elements present in a given column\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyRelation.value_counts", "modulename": "duckdb", "qualname": "DuckDBPyRelation.value_counts", "kind": "function", "doc": "value_counts(self: _duckdb.DuckDBPyRelation, column: str, groups: str = '') -> _duckdb.DuckDBPyRelation\n\nComputes the number of elements present in a given column, also projecting the original column\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyRelation.favg", "modulename": "duckdb", "qualname": "DuckDBPyRelation.favg", "kind": "function", "doc": "favg(self: _duckdb.DuckDBPyRelation, column: str, groups: str = '', window_spec: str = '', projected_columns: str = '') -> _duckdb.DuckDBPyRelation\n\nComputes the average of all values present in a given column using a more accurate floating point summation (Kahan Sum)\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyRelation.first", "modulename": "duckdb", "qualname": "DuckDBPyRelation.first", "kind": "function", "doc": "first(self: _duckdb.DuckDBPyRelation, column: str, groups: str = '', projected_columns: str = '') -> _duckdb.DuckDBPyRelation\n\nReturns the first value of a given column\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyRelation.fsum", "modulename": "duckdb", "qualname": "DuckDBPyRelation.fsum", "kind": "function", "doc": "fsum(self: _duckdb.DuckDBPyRelation, column: str, groups: str = '', window_spec: str = '', projected_columns: str = '') -> _duckdb.DuckDBPyRelation\n\nComputes the sum of all values present in a given column using a more accurate floating point summation (Kahan Sum)\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyRelation.geomean", "modulename": "duckdb", "qualname": "DuckDBPyRelation.geomean", "kind": "function", "doc": "geomean(self: _duckdb.DuckDBPyRelation, column: str, groups: str = '', projected_columns: str = '') -> _duckdb.DuckDBPyRelation\n\nComputes the geometric mean over all values present in a given column\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyRelation.histogram", "modulename": "duckdb", "qualname": "DuckDBPyRelation.histogram", "kind": "function", "doc": "histogram(self: _duckdb.DuckDBPyRelation, column: str, groups: str = '', window_spec: str = '', projected_columns: str = '') -> _duckdb.DuckDBPyRelation\n\nComputes the histogram over all values present in a given column\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyRelation.list", "modulename": "duckdb", "qualname": "DuckDBPyRelation.list", "kind": "function", "doc": "list(self: _duckdb.DuckDBPyRelation, column: str, groups: str = '', window_spec: str = '', projected_columns: str = '') -> _duckdb.DuckDBPyRelation\n\nReturns a list containing all values present in a given column\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyRelation.last", "modulename": "duckdb", "qualname": "DuckDBPyRelation.last", "kind": "function", "doc": "last(self: _duckdb.DuckDBPyRelation, column: str, groups: str = '', projected_columns: str = '') -> _duckdb.DuckDBPyRelation\n\nReturns the last value of a given column\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyRelation.max", "modulename": "duckdb", "qualname": "DuckDBPyRelation.max", "kind": "function", "doc": "max(self: _duckdb.DuckDBPyRelation, column: str, groups: str = '', window_spec: str = '', projected_columns: str = '') -> _duckdb.DuckDBPyRelation\n\nReturns the maximum value present in a given column\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyRelation.min", "modulename": "duckdb", "qualname": "DuckDBPyRelation.min", "kind": "function", "doc": "min(self: _duckdb.DuckDBPyRelation, column: str, groups: str = '', window_spec: str = '', projected_columns: str = '') -> _duckdb.DuckDBPyRelation\n\nReturns the minimum value present in a given column\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyRelation.product", "modulename": "duckdb", "qualname": "DuckDBPyRelation.product", "kind": "function", "doc": "product(self: _duckdb.DuckDBPyRelation, column: str, groups: str = '', window_spec: str = '', projected_columns: str = '') -> _duckdb.DuckDBPyRelation\n\nReturns the product of all values present in a given column\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyRelation.string_agg", "modulename": "duckdb", "qualname": "DuckDBPyRelation.string_agg", "kind": "function", "doc": "string_agg(self: _duckdb.DuckDBPyRelation, column: str, sep: str = ',', groups: str = '', window_spec: str = '', projected_columns: str = '') -> _duckdb.DuckDBPyRelation\n\nConcatenates the values present in a given column with a separator\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyRelation.sum", "modulename": "duckdb", "qualname": "DuckDBPyRelation.sum", "kind": "function", "doc": "sum(self: _duckdb.DuckDBPyRelation, column: str, groups: str = '', window_spec: str = '', projected_columns: str = '') -> _duckdb.DuckDBPyRelation\n\nComputes the sum of all values present in a given column\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyRelation.unique", "modulename": "duckdb", "qualname": "DuckDBPyRelation.unique", "kind": "function", "doc": "unique(self: _duckdb.DuckDBPyRelation, unique_aggr: str) -> _duckdb.DuckDBPyRelation\n\nReturns the distinct values in a column.\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyRelation.median", "modulename": "duckdb", "qualname": "DuckDBPyRelation.median", "kind": "function", "doc": "median(self: _duckdb.DuckDBPyRelation, column: str, groups: str = '', window_spec: str = '', projected_columns: str = '') -> _duckdb.DuckDBPyRelation\n\nComputes the median over all values present in a given column\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyRelation.mode", "modulename": "duckdb", "qualname": "DuckDBPyRelation.mode", "kind": "function", "doc": "mode(self: _duckdb.DuckDBPyRelation, column: str, groups: str = '', window_spec: str = '', projected_columns: str = '') -> _duckdb.DuckDBPyRelation\n\nComputes the mode over all values present in a given column\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyRelation.quantile_cont", "modulename": "duckdb", "qualname": "DuckDBPyRelation.quantile_cont", "kind": "function", "doc": "quantile_cont(self: _duckdb.DuckDBPyRelation, column: str, q: object = 0.5, groups: str = '', window_spec: str = '', projected_columns: str = '') -> _duckdb.DuckDBPyRelation\n\nComputes the interpolated quantile value for a given column\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyRelation.quantile_disc", "modulename": "duckdb", "qualname": "DuckDBPyRelation.quantile_disc", "kind": "function", "doc": "quantile_disc(self: _duckdb.DuckDBPyRelation, column: str, q: object = 0.5, groups: str = '', window_spec: str = '', projected_columns: str = '') -> _duckdb.DuckDBPyRelation\n\nComputes the exact quantile value for a given column\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyRelation.quantile", "modulename": "duckdb", "qualname": "DuckDBPyRelation.quantile", "kind": "function", "doc": "quantile(self: _duckdb.DuckDBPyRelation, column: str, q: object = 0.5, groups: str = '', window_spec: str = '', projected_columns: str = '') -> _duckdb.DuckDBPyRelation\n\nComputes the exact quantile value for a given column\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyRelation.stddev_pop", "modulename": "duckdb", "qualname": "DuckDBPyRelation.stddev_pop", "kind": "function", "doc": "stddev_pop(self: _duckdb.DuckDBPyRelation, column: str, groups: str = '', window_spec: str = '', projected_columns: str = '') -> _duckdb.DuckDBPyRelation\n\nComputes the population standard deviation for a given column\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyRelation.stddev_samp", "modulename": "duckdb", "qualname": "DuckDBPyRelation.stddev_samp", "kind": "function", "doc": "stddev_samp(self: _duckdb.DuckDBPyRelation, column: str, groups: str = '', window_spec: str = '', projected_columns: str = '') -> _duckdb.DuckDBPyRelation\n\nComputes the sample standard deviation for a given column\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyRelation.stddev", "modulename": "duckdb", "qualname": "DuckDBPyRelation.stddev", "kind": "function", "doc": "stddev(self: _duckdb.DuckDBPyRelation, column: str, groups: str = '', window_spec: str = '', projected_columns: str = '') -> _duckdb.DuckDBPyRelation\n\nComputes the sample standard deviation for a given column\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyRelation.std", "modulename": "duckdb", "qualname": "DuckDBPyRelation.std", "kind": "function", "doc": "std(self: _duckdb.DuckDBPyRelation, column: str, groups: str = '', window_spec: str = '', projected_columns: str = '') -> _duckdb.DuckDBPyRelation\n\nComputes the sample standard deviation for a given column\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyRelation.var_pop", "modulename": "duckdb", "qualname": "DuckDBPyRelation.var_pop", "kind": "function", "doc": "var_pop(self: _duckdb.DuckDBPyRelation, column: str, groups: str = '', window_spec: str = '', projected_columns: str = '') -> _duckdb.DuckDBPyRelation\n\nComputes the population variance for a given column\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyRelation.var_samp", "modulename": "duckdb", "qualname": "DuckDBPyRelation.var_samp", "kind": "function", "doc": "var_samp(self: _duckdb.DuckDBPyRelation, column: str, groups: str = '', window_spec: str = '', projected_columns: str = '') -> _duckdb.DuckDBPyRelation\n\nComputes the sample variance for a given column\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyRelation.variance", "modulename": "duckdb", "qualname": "DuckDBPyRelation.variance", "kind": "function", "doc": "variance(self: _duckdb.DuckDBPyRelation, column: str, groups: str = '', window_spec: str = '', projected_columns: str = '') -> _duckdb.DuckDBPyRelation\n\nComputes the sample variance for a given column\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyRelation.var", "modulename": "duckdb", "qualname": "DuckDBPyRelation.var", "kind": "function", "doc": "var(self: _duckdb.DuckDBPyRelation, column: str, groups: str = '', window_spec: str = '', projected_columns: str = '') -> _duckdb.DuckDBPyRelation\n\nComputes the sample variance for a given column\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyRelation.row_number", "modulename": "duckdb", "qualname": "DuckDBPyRelation.row_number", "kind": "function", "doc": "row_number(self: _duckdb.DuckDBPyRelation, window_spec: str, projected_columns: str = '') -> _duckdb.DuckDBPyRelation\n\nComputes the row number within the partition\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyRelation.rank", "modulename": "duckdb", "qualname": "DuckDBPyRelation.rank", "kind": "function", "doc": "rank(self: _duckdb.DuckDBPyRelation, window_spec: str, projected_columns: str = '') -> _duckdb.DuckDBPyRelation\n\nComputes the rank within the partition\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyRelation.dense_rank", "modulename": "duckdb", "qualname": "DuckDBPyRelation.dense_rank", "kind": "function", "doc": "dense_rank(self: _duckdb.DuckDBPyRelation, window_spec: str, projected_columns: str = '') -> _duckdb.DuckDBPyRelation\n\nComputes the dense rank within the partition\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyRelation.rank_dense", "modulename": "duckdb", "qualname": "DuckDBPyRelation.rank_dense", "kind": "function", "doc": "rank_dense(self: _duckdb.DuckDBPyRelation, window_spec: str, projected_columns: str = '') -> _duckdb.DuckDBPyRelation\n\nComputes the dense rank within the partition\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyRelation.percent_rank", "modulename": "duckdb", "qualname": "DuckDBPyRelation.percent_rank", "kind": "function", "doc": "percent_rank(self: _duckdb.DuckDBPyRelation, window_spec: str, projected_columns: str = '') -> _duckdb.DuckDBPyRelation\n\nComputes the relative rank within the partition\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyRelation.cume_dist", "modulename": "duckdb", "qualname": "DuckDBPyRelation.cume_dist", "kind": "function", "doc": "cume_dist(self: _duckdb.DuckDBPyRelation, window_spec: str, projected_columns: str = '') -> _duckdb.DuckDBPyRelation\n\nComputes the cumulative distribution within the partition\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyRelation.first_value", "modulename": "duckdb", "qualname": "DuckDBPyRelation.first_value", "kind": "function", "doc": "first_value(self: _duckdb.DuckDBPyRelation, column: str, window_spec: str = '', projected_columns: str = '') -> _duckdb.DuckDBPyRelation\n\nComputes the first value within the group or partition\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyRelation.n_tile", "modulename": "duckdb", "qualname": "DuckDBPyRelation.n_tile", "kind": "function", "doc": "n_tile(self: _duckdb.DuckDBPyRelation, window_spec: str, num_buckets: typing.SupportsInt, projected_columns: str = '') -> _duckdb.DuckDBPyRelation\n\nDivides the partition as equally as possible into num_buckets\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyRelation.lag", "modulename": "duckdb", "qualname": "DuckDBPyRelation.lag", "kind": "function", "doc": "lag(self: _duckdb.DuckDBPyRelation, column: str, window_spec: str, offset: typing.SupportsInt = 1, default_value: str = 'NULL', ignore_nulls: bool = False, projected_columns: str = '') -> _duckdb.DuckDBPyRelation\n\nComputes the lag within the partition\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyRelation.last_value", "modulename": "duckdb", "qualname": "DuckDBPyRelation.last_value", "kind": "function", "doc": "last_value(self: _duckdb.DuckDBPyRelation, column: str, window_spec: str = '', projected_columns: str = '') -> _duckdb.DuckDBPyRelation\n\nComputes the last value within the group or partition\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyRelation.lead", "modulename": "duckdb", "qualname": "DuckDBPyRelation.lead", "kind": "function", "doc": "lead(self: _duckdb.DuckDBPyRelation, column: str, window_spec: str, offset: typing.SupportsInt = 1, default_value: str = 'NULL', ignore_nulls: bool = False, projected_columns: str = '') -> _duckdb.DuckDBPyRelation\n\nComputes the lead within the partition\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyRelation.nth_value", "modulename": "duckdb", "qualname": "DuckDBPyRelation.nth_value", "kind": "function", "doc": "nth_value(self: _duckdb.DuckDBPyRelation, column: str, window_spec: str, offset: typing.SupportsInt, ignore_nulls: bool = False, projected_columns: str = '') -> _duckdb.DuckDBPyRelation\n\nComputes the nth value within the partition\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyRelation.union", "modulename": "duckdb", "qualname": "DuckDBPyRelation.union", "kind": "function", "doc": "union(self: _duckdb.DuckDBPyRelation, union_rel: _duckdb.DuckDBPyRelation) -> _duckdb.DuckDBPyRelation\n\nCreate the set union of this relation object with another relation object in other_rel\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyRelation.except_", "modulename": "duckdb", "qualname": "DuckDBPyRelation.except_", "kind": "function", "doc": "except_(self: _duckdb.DuckDBPyRelation, other_rel: _duckdb.DuckDBPyRelation) -> _duckdb.DuckDBPyRelation\n\nCreate the set except of this relation object with another relation object in other_rel\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyRelation.intersect", "modulename": "duckdb", "qualname": "DuckDBPyRelation.intersect", "kind": "function", "doc": "intersect(self: _duckdb.DuckDBPyRelation, other_rel: _duckdb.DuckDBPyRelation) -> _duckdb.DuckDBPyRelation\n\nCreate the set intersection of this relation object with another relation object in other_rel\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyRelation.describe", "modulename": "duckdb", "qualname": "DuckDBPyRelation.describe", "kind": "function", "doc": "describe(self: _duckdb.DuckDBPyRelation) -> _duckdb.DuckDBPyRelation\n\nGives basic statistics (e.g., min, max) and if NULL exists for each column of the relation.\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyRelation.explain", "modulename": "duckdb", "qualname": "DuckDBPyRelation.explain", "kind": "function", "doc": "explain(self: _duckdb.DuckDBPyRelation, type: _duckdb.ExplainType = 'standard') -> str\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyRelation.execute", "modulename": "duckdb", "qualname": "DuckDBPyRelation.execute", "kind": "function", "doc": "execute(self: _duckdb.DuckDBPyRelation) -> _duckdb.DuckDBPyRelation\n\nTransform the relation into a result set\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyRelation.close", "modulename": "duckdb", "qualname": "DuckDBPyRelation.close", "kind": "function", "doc": "close(self: _duckdb.DuckDBPyRelation) -> None\n\nCloses the result\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyRelation.to_parquet", "modulename": "duckdb", "qualname": "DuckDBPyRelation.to_parquet", "kind": "function", "doc": "to_parquet(self: _duckdb.DuckDBPyRelation, file_name: str, *, compression: object = None, field_ids: object = None, row_group_size_bytes: object = None, row_group_size: object = None, overwrite: object = None, per_thread_output: object = None, use_tmp_file: object = None, partition_by: object = None, write_partition_columns: object = None, append: object = None, filename_pattern: object = None, file_size_bytes: object = None) -> None\n\nWrite the relation object to a Parquet file in 'file_name'\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyRelation.write_parquet", "modulename": "duckdb", "qualname": "DuckDBPyRelation.write_parquet", "kind": "function", "doc": "write_parquet(self: _duckdb.DuckDBPyRelation, file_name: str, *, compression: object = None, field_ids: object = None, row_group_size_bytes: object = None, row_group_size: object = None, overwrite: object = None, per_thread_output: object = None, use_tmp_file: object = None, partition_by: object = None, write_partition_columns: object = None, append: object = None, filename_pattern: object = None, file_size_bytes: object = None) -> None\n\nWrite the relation object to a Parquet file in 'file_name'\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyRelation.to_csv", "modulename": "duckdb", "qualname": "DuckDBPyRelation.to_csv", "kind": "function", "doc": "to_csv(self: _duckdb.DuckDBPyRelation, file_name: str, *, sep: object = None, na_rep: object = None, header: object = None, quotechar: object = None, escapechar: object = None, date_format: object = None, timestamp_format: object = None, quoting: object = None, encoding: object = None, compression: object = None, overwrite: object = None, per_thread_output: object = None, use_tmp_file: object = None, partition_by: object = None, write_partition_columns: object = None) -> None\n\nWrite the relation object to a CSV file in 'file_name'\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyRelation.write_csv", "modulename": "duckdb", "qualname": "DuckDBPyRelation.write_csv", "kind": "function", "doc": "write_csv(self: _duckdb.DuckDBPyRelation, file_name: str, *, sep: object = None, na_rep: object = None, header: object = None, quotechar: object = None, escapechar: object = None, date_format: object = None, timestamp_format: object = None, quoting: object = None, encoding: object = None, compression: object = None, overwrite: object = None, per_thread_output: object = None, use_tmp_file: object = None, partition_by: object = None, write_partition_columns: object = None) -> None\n\nWrite the relation object to a CSV file in 'file_name'\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyRelation.fetchone", "modulename": "duckdb", "qualname": "DuckDBPyRelation.fetchone", "kind": "function", "doc": "fetchone(self: _duckdb.DuckDBPyRelation) -> typing.Optional[tuple]\n\nExecute and fetch a single row as a tuple\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyRelation.fetchmany", "modulename": "duckdb", "qualname": "DuckDBPyRelation.fetchmany", "kind": "function", "doc": "fetchmany(self: _duckdb.DuckDBPyRelation, size: typing.SupportsInt = 1) -> list\n\nExecute and fetch the next set of rows as a list of tuples\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyRelation.fetchall", "modulename": "duckdb", "qualname": "DuckDBPyRelation.fetchall", "kind": "function", "doc": "fetchall(self: _duckdb.DuckDBPyRelation) -> list\n\nExecute and fetch all rows as a list of tuples\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyRelation.fetchnumpy", "modulename": "duckdb", "qualname": "DuckDBPyRelation.fetchnumpy", "kind": "function", "doc": "fetchnumpy(self: _duckdb.DuckDBPyRelation) -> dict\n\nExecute and fetch all rows as a Python dict mapping each column to one numpy arrays\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyRelation.df", "modulename": "duckdb", "qualname": "DuckDBPyRelation.df", "kind": "function", "doc": "df(self: _duckdb.DuckDBPyRelation, *, date_as_object: bool = False) -> pandas.DataFrame\n\nExecute and fetch all rows as a pandas DataFrame\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyRelation.fetchdf", "modulename": "duckdb", "qualname": "DuckDBPyRelation.fetchdf", "kind": "function", "doc": "fetchdf(self: _duckdb.DuckDBPyRelation, *, date_as_object: bool = False) -> pandas.DataFrame\n\nExecute and fetch all rows as a pandas DataFrame\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyRelation.to_df", "modulename": "duckdb", "qualname": "DuckDBPyRelation.to_df", "kind": "function", "doc": "to_df(self: _duckdb.DuckDBPyRelation, *, date_as_object: bool = False) -> pandas.DataFrame\n\nExecute and fetch all rows as a pandas DataFrame\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyRelation.fetch_df_chunk", "modulename": "duckdb", "qualname": "DuckDBPyRelation.fetch_df_chunk", "kind": "function", "doc": "fetch_df_chunk(self: _duckdb.DuckDBPyRelation, vectors_per_chunk: typing.SupportsInt = 1, *, date_as_object: bool = False) -> pandas.DataFrame\n\nExecute and fetch a chunk of the rows\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyRelation.arrow", "modulename": "duckdb", "qualname": "DuckDBPyRelation.arrow", "kind": "function", "doc": "arrow(self: _duckdb.DuckDBPyRelation, batch_size: typing.SupportsInt = 1000000) -> pyarrow.lib.RecordBatchReader\n\nExecute and return an Arrow Record Batch Reader that yields all rows\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyRelation.fetch_arrow_table", "modulename": "duckdb", "qualname": "DuckDBPyRelation.fetch_arrow_table", "kind": "function", "doc": "fetch_arrow_table(self: _duckdb.DuckDBPyRelation, batch_size: typing.SupportsInt = 1000000) -> pyarrow.lib.Table\n\nExecute and fetch all rows as an Arrow Table\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyRelation.to_arrow_table", "modulename": "duckdb", "qualname": "DuckDBPyRelation.to_arrow_table", "kind": "function", "doc": "to_arrow_table(self: _duckdb.DuckDBPyRelation, batch_size: typing.SupportsInt = 1000000) -> pyarrow.lib.Table\n\nExecute and fetch all rows as an Arrow Table\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyRelation.pl", "modulename": "duckdb", "qualname": "DuckDBPyRelation.pl", "kind": "function", "doc": "pl(self: _duckdb.DuckDBPyRelation, batch_size: typing.SupportsInt = 1000000, *, lazy: bool = False) -> duckdb::PolarsDataFrame\n\nExecute and fetch all rows as a Polars DataFrame\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyRelation.torch", "modulename": "duckdb", "qualname": "DuckDBPyRelation.torch", "kind": "function", "doc": "torch(self: _duckdb.DuckDBPyRelation) -> dict\n\nFetch a result as dict of PyTorch Tensors\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyRelation.tf", "modulename": "duckdb", "qualname": "DuckDBPyRelation.tf", "kind": "function", "doc": "tf(self: _duckdb.DuckDBPyRelation) -> dict\n\nFetch a result as dict of TensorFlow Tensors\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyRelation.fetch_record_batch", "modulename": "duckdb", "qualname": "DuckDBPyRelation.fetch_record_batch", "kind": "function", "doc": "fetch_record_batch(self: _duckdb.DuckDBPyRelation, rows_per_batch: typing.SupportsInt = 1000000) -> pyarrow.lib.RecordBatchReader\n\nExecute and return an Arrow Record Batch Reader that yields all rows\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyRelation.fetch_arrow_reader", "modulename": "duckdb", "qualname": "DuckDBPyRelation.fetch_arrow_reader", "kind": "function", "doc": "fetch_arrow_reader(self: _duckdb.DuckDBPyRelation, batch_size: typing.SupportsInt = 1000000) -> pyarrow.lib.RecordBatchReader\n\nExecute and return an Arrow Record Batch Reader that yields all rows\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyRelation.record_batch", "modulename": "duckdb", "qualname": "DuckDBPyRelation.record_batch", "kind": "function", "doc": "record_batch(self: object, batch_size: typing.SupportsInt = 1000000) -> object\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyRelation.filter", "modulename": "duckdb", "qualname": "DuckDBPyRelation.filter", "kind": "function", "doc": "filter(self: _duckdb.DuckDBPyRelation, filter_expr: object) -> _duckdb.DuckDBPyRelation\n\nFilter the relation object by the filter in filter_expr\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyRelation.select", "modulename": "duckdb", "qualname": "DuckDBPyRelation.select", "kind": "function", "doc": "select(self: _duckdb.DuckDBPyRelation, *args, groups: str = '') -> _duckdb.DuckDBPyRelation\n\nProject the relation object by the projection in project_expr\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyRelation.project", "modulename": "duckdb", "qualname": "DuckDBPyRelation.project", "kind": "function", "doc": "project(self: _duckdb.DuckDBPyRelation, *args, groups: str = '') -> _duckdb.DuckDBPyRelation\n\nProject the relation object by the projection in project_expr\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyRelation.select_types", "modulename": "duckdb", "qualname": "DuckDBPyRelation.select_types", "kind": "function", "doc": "select_types(self: _duckdb.DuckDBPyRelation, types: object) -> _duckdb.DuckDBPyRelation\n\nSelect columns from the relation, by filtering based on type(s)\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyRelation.select_dtypes", "modulename": "duckdb", "qualname": "DuckDBPyRelation.select_dtypes", "kind": "function", "doc": "select_dtypes(self: _duckdb.DuckDBPyRelation, types: object) -> _duckdb.DuckDBPyRelation\n\nSelect columns from the relation, by filtering based on type(s)\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyRelation.set_alias", "modulename": "duckdb", "qualname": "DuckDBPyRelation.set_alias", "kind": "function", "doc": "set_alias(self: _duckdb.DuckDBPyRelation, alias: str) -> _duckdb.DuckDBPyRelation\n\nRename the relation object to new alias\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyRelation.order", "modulename": "duckdb", "qualname": "DuckDBPyRelation.order", "kind": "function", "doc": "order(self: _duckdb.DuckDBPyRelation, order_expr: str) -> _duckdb.DuckDBPyRelation\n\nReorder the relation object by order_expr\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyRelation.sort", "modulename": "duckdb", "qualname": "DuckDBPyRelation.sort", "kind": "function", "doc": "sort(self: _duckdb.DuckDBPyRelation, *args) -> _duckdb.DuckDBPyRelation\n\nReorder the relation object by the provided expressions\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyRelation.aggregate", "modulename": "duckdb", "qualname": "DuckDBPyRelation.aggregate", "kind": "function", "doc": "aggregate(self: _duckdb.DuckDBPyRelation, aggr_expr: object, group_expr: str = '') -> _duckdb.DuckDBPyRelation\n\nCompute the aggregate aggr_expr by the optional groups group_expr on the relation\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyRelation.apply", "modulename": "duckdb", "qualname": "DuckDBPyRelation.apply", "kind": "function", "doc": "apply(self: _duckdb.DuckDBPyRelation, function_name: str, function_aggr: str, group_expr: str = '', function_parameter: str = '', projected_columns: str = '') -> _duckdb.DuckDBPyRelation\n\nCompute the function of a single column or a list of columns by the optional groups on the relation\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyRelation.join", "modulename": "duckdb", "qualname": "DuckDBPyRelation.join", "kind": "function", "doc": "join(self: _duckdb.DuckDBPyRelation, other_rel: _duckdb.DuckDBPyRelation, condition: object, how: str = 'inner') -> _duckdb.DuckDBPyRelation\n\nJoin the relation object with another relation object in other_rel using the join condition expression in join_condition. Types supported are 'inner', 'left', 'right', 'outer', 'semi' and 'anti'\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyRelation.cross", "modulename": "duckdb", "qualname": "DuckDBPyRelation.cross", "kind": "function", "doc": "cross(self: _duckdb.DuckDBPyRelation, other_rel: _duckdb.DuckDBPyRelation) -> _duckdb.DuckDBPyRelation\n\nCreate cross/cartesian product of two relational objects\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyRelation.distinct", "modulename": "duckdb", "qualname": "DuckDBPyRelation.distinct", "kind": "function", "doc": "distinct(self: _duckdb.DuckDBPyRelation) -> _duckdb.DuckDBPyRelation\n\nRetrieve distinct rows from this relation object\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyRelation.limit", "modulename": "duckdb", "qualname": "DuckDBPyRelation.limit", "kind": "function", "doc": "limit(self: _duckdb.DuckDBPyRelation, n: typing.SupportsInt, offset: typing.SupportsInt = 0) -> _duckdb.DuckDBPyRelation\n\nOnly retrieve the first n rows from this relation object, starting at offset\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyRelation.insert", "modulename": "duckdb", "qualname": "DuckDBPyRelation.insert", "kind": "function", "doc": "insert(self: _duckdb.DuckDBPyRelation, values: object) -> None\n\nInserts the given values into the relation\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyRelation.update", "modulename": "duckdb", "qualname": "DuckDBPyRelation.update", "kind": "function", "doc": "update(self: _duckdb.DuckDBPyRelation, set: object, *, condition: object = None) -> None\n\nUpdate the given relation with the provided expressions\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyRelation.query", "modulename": "duckdb", "qualname": "DuckDBPyRelation.query", "kind": "function", "doc": "query(self: _duckdb.DuckDBPyRelation, virtual_table_name: str, sql_query: str) -> _duckdb.DuckDBPyRelation\n\nRun the given SQL query in sql_query on the view named virtual_table_name that refers to the relation object\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyRelation.insert_into", "modulename": "duckdb", "qualname": "DuckDBPyRelation.insert_into", "kind": "function", "doc": "insert_into(self: _duckdb.DuckDBPyRelation, table_name: str) -> None\n\nInserts the relation object into an existing table named table_name\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyRelation.create", "modulename": "duckdb", "qualname": "DuckDBPyRelation.create", "kind": "function", "doc": "create(self: _duckdb.DuckDBPyRelation, table_name: str) -> None\n\nCreates a new table named table_name with the contents of the relation object\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyRelation.to_table", "modulename": "duckdb", "qualname": "DuckDBPyRelation.to_table", "kind": "function", "doc": "to_table(self: _duckdb.DuckDBPyRelation, table_name: str) -> None\n\nCreates a new table named table_name with the contents of the relation object\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyRelation.create_view", "modulename": "duckdb", "qualname": "DuckDBPyRelation.create_view", "kind": "function", "doc": "create_view(self: _duckdb.DuckDBPyRelation, view_name: str, replace: bool = True) -> _duckdb.DuckDBPyRelation\n\nCreates a view named view_name that refers to the relation object\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyRelation.to_view", "modulename": "duckdb", "qualname": "DuckDBPyRelation.to_view", "kind": "function", "doc": "to_view(self: _duckdb.DuckDBPyRelation, view_name: str, replace: bool = True) -> _duckdb.DuckDBPyRelation\n\nCreates a view named view_name that refers to the relation object\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyRelation.map", "modulename": "duckdb", "qualname": "DuckDBPyRelation.map", "kind": "function", "doc": "map(self: _duckdb.DuckDBPyRelation, map_function: collections.abc.Callable, *, schema: typing.Optional[object] = None) -> _duckdb.DuckDBPyRelation\n\nCalls the passed function on the relation\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyRelation.show", "modulename": "duckdb", "qualname": "DuckDBPyRelation.show", "kind": "function", "doc": "show(self: _duckdb.DuckDBPyRelation, *, max_width: typing.Optional[typing.SupportsInt] = None, max_rows: typing.Optional[typing.SupportsInt] = None, max_col_width: typing.Optional[typing.SupportsInt] = None, null_value: typing.Optional[str] = None, render_mode: object = None) -> None\n\nDisplay a summary of the data\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.DuckDBPyRelation.sql_query", "modulename": "duckdb", "qualname": "DuckDBPyRelation.sql_query", "kind": "function", "doc": "sql_query(self: _duckdb.DuckDBPyRelation) -> str\n\nGet the SQL query that is equivalent to the relation\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.Error", "modulename": "duckdb", "qualname": "Error", "kind": "class", "doc": "Common base class for all non-exit exceptions.\n", "bases": "builtins.Exception"}, {"fullname": "duckdb.ExpectedResultType", "modulename": "duckdb", "qualname": "ExpectedResultType", "kind": "class", "doc": "Members:\n\nQUERY_RESULT\n\nCHANGED_ROWS\n\nNOTHING\n", "bases": "pybind11_builtins.pybind11_object"}, {"fullname": "duckdb.ExpectedResultType.__init__", "modulename": "duckdb", "qualname": "ExpectedResultType.__init__", "kind": "function", "doc": "__init__(self: _duckdb.ExpectedResultType, value: typing.SupportsInt) -> None\n", "signature": "()"}, {"fullname": "duckdb.ExpectedResultType.name", "modulename": "duckdb", "qualname": "ExpectedResultType.name", "kind": "variable", "doc": "name(self: object, /) -> str\n"}, {"fullname": "duckdb.ExpectedResultType.value", "modulename": "duckdb", "qualname": "ExpectedResultType.value", "kind": "variable", "doc": "(arg0: _duckdb.ExpectedResultType) -> int\n"}, {"fullname": "duckdb.ExpectedResultType.QUERY_RESULT", "modulename": "duckdb", "qualname": "ExpectedResultType.QUERY_RESULT", "kind": "variable", "doc": "\n", "default_value": "<ExpectedResultType.QUERY_RESULT: 0>"}, {"fullname": "duckdb.ExpectedResultType.CHANGED_ROWS", "modulename": "duckdb", "qualname": "ExpectedResultType.CHANGED_ROWS", "kind": "variable", "doc": "\n", "default_value": "<ExpectedResultType.CHANGED_ROWS: 1>"}, {"fullname": "duckdb.ExpectedResultType.NOTHING", "modulename": "duckdb", "qualname": "ExpectedResultType.NOTHING", "kind": "variable", "doc": "\n", "default_value": "<ExpectedResultType.NOTHING: 2>"}, {"fullname": "duckdb.ExplainType", "modulename": "duckdb", "qualname": "ExplainType", "kind": "class", "doc": "Members:\n\nSTANDARD\n\nANALYZE\n", "bases": "pybind11_builtins.pybind11_object"}, {"fullname": "duckdb.ExplainType.__init__", "modulename": "duckdb", "qualname": "ExplainType.__init__", "kind": "function", "doc": "__init__(self: _duckdb.ExplainType, value: typing.SupportsInt) -> None\n", "signature": "()"}, {"fullname": "duckdb.ExplainType.name", "modulename": "duckdb", "qualname": "ExplainType.name", "kind": "variable", "doc": "name(self: object, /) -> str\n"}, {"fullname": "duckdb.ExplainType.value", "modulename": "duckdb", "qualname": "ExplainType.value", "kind": "variable", "doc": "(arg0: _duckdb.ExplainType) -> int\n"}, {"fullname": "duckdb.ExplainType.STANDARD", "modulename": "duckdb", "qualname": "ExplainType.STANDARD", "kind": "variable", "doc": "\n", "default_value": "<ExplainType.STANDARD: 0>"}, {"fullname": "duckdb.ExplainType.ANALYZE", "modulename": "duckdb", "qualname": "ExplainType.ANALYZE", "kind": "variable", "doc": "\n", "default_value": "<ExplainType.ANALYZE: 1>"}, {"fullname": "duckdb.Expression", "modulename": "duckdb", "qualname": "Expression", "kind": "class", "doc": "\n", "bases": "pybind11_builtins.pybind11_object"}, {"fullname": "duckdb.Expression.__init__", "modulename": "duckdb", "qualname": "Expression.__init__", "kind": "function", "doc": "__init__(args, *kwargs)\nOverloaded function.\n\n<ol>\n<li>__init__(self: _duckdb.Expression, arg0: str) -> None</li>\n<li>__init__(self: _duckdb.Expression, arg0: object) -> None</li>\n</ol>\n", "signature": "()"}, {"fullname": "duckdb.Expression.show", "modulename": "duckdb", "qualname": "Expression.show", "kind": "function", "doc": "show(self: _duckdb.Expression) -> None\n\nPrint the stringified version of the expression.\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.Expression.asc", "modulename": "duckdb", "qualname": "Expression.asc", "kind": "function", "doc": "asc(self: _duckdb.Expression) -> _duckdb.Expression\n\nSet the order by modifier to ASCENDING.\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.Expression.desc", "modulename": "duckdb", "qualname": "Expression.desc", "kind": "function", "doc": "desc(self: _duckdb.Expression) -> _duckdb.Expression\n\nSet the order by modifier to DESCENDING.\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.Expression.nulls_first", "modulename": "duckdb", "qualname": "Expression.nulls_first", "kind": "function", "doc": "nulls_first(self: _duckdb.Expression) -> _duckdb.Expression\n\nSet the NULL order by modifier to NULLS FIRST.\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.Expression.nulls_last", "modulename": "duckdb", "qualname": "Expression.nulls_last", "kind": "function", "doc": "nulls_last(self: _duckdb.Expression) -> _duckdb.Expression\n\nSet the NULL order by modifier to NULLS LAST.\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.Expression.isnull", "modulename": "duckdb", "qualname": "Expression.isnull", "kind": "function", "doc": "isnull(self: _duckdb.Expression) -> _duckdb.Expression\n\nCreate a binary IS NULL expression from self\n\nReturns:\n DuckDBPyExpression: self IS NULL\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.Expression.isnotnull", "modulename": "duckdb", "qualname": "Expression.isnotnull", "kind": "function", "doc": "isnotnull(self: _duckdb.Expression) -> _duckdb.Expression\n\nCreate a binary IS NOT NULL expression from self\n\nReturns:\n DuckDBPyExpression: self IS NOT NULL\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.Expression.isin", "modulename": "duckdb", "qualname": "Expression.isin", "kind": "function", "doc": "isin(self: _duckdb.Expression, *args) -> _duckdb.Expression\n\nReturn an IN expression comparing self to the input arguments.\n\nReturns:\n DuckDBPyExpression: The compare IN expression\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.Expression.isnotin", "modulename": "duckdb", "qualname": "Expression.isnotin", "kind": "function", "doc": "isnotin(self: _duckdb.Expression, *args) -> _duckdb.Expression\n\nReturn a NOT IN expression comparing self to the input arguments.\n\nReturns:\n DuckDBPyExpression: The compare NOT IN expression\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.Expression.get_name", "modulename": "duckdb", "qualname": "Expression.get_name", "kind": "function", "doc": "get_name(self: _duckdb.Expression) -> str\n\nReturn the stringified version of the expression.\n\nReturns:\n str: The string representation.\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.Expression.alias", "modulename": "duckdb", "qualname": "Expression.alias", "kind": "function", "doc": "alias(self: _duckdb.Expression, arg0: str) -> _duckdb.Expression\n\nCreate a copy of this expression with the given alias.\n\nParameters:\n name: The alias to use for the expression, this will affect how it can be referenced.\n\nReturns:\n Expression: self with an alias.\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.Expression.when", "modulename": "duckdb", "qualname": "Expression.when", "kind": "function", "doc": "when(self: _duckdb.Expression, condition: _duckdb.Expression, value: _duckdb.Expression) -> _duckdb.Expression\n\nAdd an additional WHEN <condition> THEN <value> clause to the CaseExpression.\n\nParameters:\n condition: The condition that must be met.\n value: The value to use if the condition is met.\n\nReturns:\n CaseExpression: self with an additional WHEN clause.\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.Expression.otherwise", "modulename": "duckdb", "qualname": "Expression.otherwise", "kind": "function", "doc": "otherwise(self: _duckdb.Expression, value: _duckdb.Expression) -> _duckdb.Expression\n\nAdd an ELSE <value> clause to the CaseExpression.\n\nParameters:\n value: The value to use if none of the WHEN conditions are met.\n\nReturns:\n CaseExpression: self with an ELSE clause.\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.Expression.cast", "modulename": "duckdb", "qualname": "Expression.cast", "kind": "function", "doc": "cast(self: _duckdb.Expression, type: _duckdb._sqltypes.DuckDBPyType) -> _duckdb.Expression\n\nCreate a CastExpression to type from self\n\nParameters:\n type: The type to cast to\n\nReturns:\n CastExpression: self::type\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.Expression.between", "modulename": "duckdb", "qualname": "Expression.between", "kind": "function", "doc": "between(self: _duckdb.Expression, lower: _duckdb.Expression, upper: _duckdb.Expression) -> _duckdb.Expression\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.Expression.collate", "modulename": "duckdb", "qualname": "Expression.collate", "kind": "function", "doc": "collate(self: _duckdb.Expression, collation: str) -> _duckdb.Expression\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.FatalException", "modulename": "duckdb", "qualname": "FatalException", "kind": "class", "doc": "Common base class for all non-exit exceptions.\n", "bases": "_duckdb.DatabaseError"}, {"fullname": "duckdb.FloatValue", "modulename": "duckdb", "qualname": "FloatValue", "kind": "class", "doc": "\n", "bases": "duckdb.value.constant.Value"}, {"fullname": "duckdb.FloatValue.__init__", "modulename": "duckdb", "qualname": "FloatValue.__init__", "kind": "function", "doc": "\n", "signature": "(object: Any)"}, {"fullname": "duckdb.FunctionExpression", "modulename": "duckdb", "qualname": "FunctionExpression", "kind": "function", "doc": "FunctionExpression(function_name: str, *args) -> _duckdb.Expression\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.HTTPException", "modulename": "duckdb", "qualname": "HTTPException", "kind": "class", "doc": "Thrown when an error occurs in the httpfs extension, or whilst downloading an extension.\n", "bases": "_duckdb.IOException"}, {"fullname": "duckdb.HTTPException.status_code", "modulename": "duckdb", "qualname": "HTTPException.status_code", "kind": "variable", "doc": "\n", "annotation": ": int"}, {"fullname": "duckdb.HTTPException.body", "modulename": "duckdb", "qualname": "HTTPException.body", "kind": "variable", "doc": "\n", "annotation": ": str"}, {"fullname": "duckdb.HTTPException.reason", "modulename": "duckdb", "qualname": "HTTPException.reason", "kind": "variable", "doc": "\n", "annotation": ": str"}, {"fullname": "duckdb.HTTPException.headers", "modulename": "duckdb", "qualname": "HTTPException.headers", "kind": "variable", "doc": "\n", "annotation": ": Dict[str, str]"}, {"fullname": "duckdb.HugeIntegerValue", "modulename": "duckdb", "qualname": "HugeIntegerValue", "kind": "class", "doc": "\n", "bases": "duckdb.value.constant.Value"}, {"fullname": "duckdb.HugeIntegerValue.__init__", "modulename": "duckdb", "qualname": "HugeIntegerValue.__init__", "kind": "function", "doc": "\n", "signature": "(object: Any)"}, {"fullname": "duckdb.IOException", "modulename": "duckdb", "qualname": "IOException", "kind": "class", "doc": "Common base class for all non-exit exceptions.\n", "bases": "_duckdb.OperationalError"}, {"fullname": "duckdb.IntegerValue", "modulename": "duckdb", "qualname": "IntegerValue", "kind": "class", "doc": "\n", "bases": "duckdb.value.constant.Value"}, {"fullname": "duckdb.IntegerValue.__init__", "modulename": "duckdb", "qualname": "IntegerValue.__init__", "kind": "function", "doc": "\n", "signature": "(object: Any)"}, {"fullname": "duckdb.IntegrityError", "modulename": "duckdb", "qualname": "IntegrityError", "kind": "class", "doc": "Common base class for all non-exit exceptions.\n", "bases": "_duckdb.DatabaseError"}, {"fullname": "duckdb.InternalError", "modulename": "duckdb", "qualname": "InternalError", "kind": "class", "doc": "Common base class for all non-exit exceptions.\n", "bases": "_duckdb.DatabaseError"}, {"fullname": "duckdb.InternalException", "modulename": "duckdb", "qualname": "InternalException", "kind": "class", "doc": "Common base class for all non-exit exceptions.\n", "bases": "_duckdb.InternalError"}, {"fullname": "duckdb.InterruptException", "modulename": "duckdb", "qualname": "InterruptException", "kind": "class", "doc": "Common base class for all non-exit exceptions.\n", "bases": "_duckdb.DatabaseError"}, {"fullname": "duckdb.IntervalValue", "modulename": "duckdb", "qualname": "IntervalValue", "kind": "class", "doc": "\n", "bases": "duckdb.value.constant.Value"}, {"fullname": "duckdb.IntervalValue.__init__", "modulename": "duckdb", "qualname": "IntervalValue.__init__", "kind": "function", "doc": "\n", "signature": "(object: Any)"}, {"fullname": "duckdb.InvalidInputException", "modulename": "duckdb", "qualname": "InvalidInputException", "kind": "class", "doc": "Common base class for all non-exit exceptions.\n", "bases": "_duckdb.ProgrammingError"}, {"fullname": "duckdb.InvalidTypeException", "modulename": "duckdb", "qualname": "InvalidTypeException", "kind": "class", "doc": "Common base class for all non-exit exceptions.\n", "bases": "_duckdb.ProgrammingError"}, {"fullname": "duckdb.LambdaExpression", "modulename": "duckdb", "qualname": "LambdaExpression", "kind": "function", "doc": "LambdaExpression(lhs: object, rhs: _duckdb.Expression) -> _duckdb.Expression\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.ListValue", "modulename": "duckdb", "qualname": "ListValue", "kind": "class", "doc": "\n", "bases": "duckdb.value.constant.Value"}, {"fullname": "duckdb.ListValue.__init__", "modulename": "duckdb", "qualname": "ListValue.__init__", "kind": "function", "doc": "\n", "signature": "(object: Any, child_type: _duckdb._sqltypes.DuckDBPyType)"}, {"fullname": "duckdb.LongValue", "modulename": "duckdb", "qualname": "LongValue", "kind": "class", "doc": "\n", "bases": "duckdb.value.constant.Value"}, {"fullname": "duckdb.LongValue.__init__", "modulename": "duckdb", "qualname": "LongValue.__init__", "kind": "function", "doc": "\n", "signature": "(object: Any)"}, {"fullname": "duckdb.MapValue", "modulename": "duckdb", "qualname": "MapValue", "kind": "class", "doc": "\n", "bases": "duckdb.value.constant.Value"}, {"fullname": "duckdb.MapValue.__init__", "modulename": "duckdb", "qualname": "MapValue.__init__", "kind": "function", "doc": "\n", "signature": "(\tobject: Any,\tkey_type: _duckdb._sqltypes.DuckDBPyType,\tvalue_type: _duckdb._sqltypes.DuckDBPyType)"}, {"fullname": "duckdb.NotImplementedException", "modulename": "duckdb", "qualname": "NotImplementedException", "kind": "class", "doc": "Common base class for all non-exit exceptions.\n", "bases": "_duckdb.NotSupportedError"}, {"fullname": "duckdb.NotSupportedError", "modulename": "duckdb", "qualname": "NotSupportedError", "kind": "class", "doc": "Common base class for all non-exit exceptions.\n", "bases": "_duckdb.DatabaseError"}, {"fullname": "duckdb.NullValue", "modulename": "duckdb", "qualname": "NullValue", "kind": "class", "doc": "\n", "bases": "duckdb.value.constant.Value"}, {"fullname": "duckdb.OperationalError", "modulename": "duckdb", "qualname": "OperationalError", "kind": "class", "doc": "Common base class for all non-exit exceptions.\n", "bases": "_duckdb.DatabaseError"}, {"fullname": "duckdb.OutOfMemoryException", "modulename": "duckdb", "qualname": "OutOfMemoryException", "kind": "class", "doc": "Common base class for all non-exit exceptions.\n", "bases": "_duckdb.OperationalError"}, {"fullname": "duckdb.OutOfRangeException", "modulename": "duckdb", "qualname": "OutOfRangeException", "kind": "class", "doc": "Common base class for all non-exit exceptions.\n", "bases": "_duckdb.DataError"}, {"fullname": "duckdb.ParserException", "modulename": "duckdb", "qualname": "ParserException", "kind": "class", "doc": "Common base class for all non-exit exceptions.\n", "bases": "_duckdb.ProgrammingError"}, {"fullname": "duckdb.PermissionException", "modulename": "duckdb", "qualname": "PermissionException", "kind": "class", "doc": "Common base class for all non-exit exceptions.\n", "bases": "_duckdb.DatabaseError"}, {"fullname": "duckdb.ProgrammingError", "modulename": "duckdb", "qualname": "ProgrammingError", "kind": "class", "doc": "Common base class for all non-exit exceptions.\n", "bases": "_duckdb.DatabaseError"}, {"fullname": "duckdb.PythonExceptionHandling", "modulename": "duckdb", "qualname": "PythonExceptionHandling", "kind": "class", "doc": "Members:\n\nDEFAULT\n\nRETURN_NULL\n", "bases": "pybind11_builtins.pybind11_object"}, {"fullname": "duckdb.PythonExceptionHandling.__init__", "modulename": "duckdb", "qualname": "PythonExceptionHandling.__init__", "kind": "function", "doc": "__init__(self: _duckdb.PythonExceptionHandling, value: typing.SupportsInt) -> None\n", "signature": "()"}, {"fullname": "duckdb.PythonExceptionHandling.name", "modulename": "duckdb", "qualname": "PythonExceptionHandling.name", "kind": "variable", "doc": "name(self: object, /) -> str\n"}, {"fullname": "duckdb.PythonExceptionHandling.value", "modulename": "duckdb", "qualname": "PythonExceptionHandling.value", "kind": "variable", "doc": "(arg0: _duckdb.PythonExceptionHandling) -> int\n"}, {"fullname": "duckdb.PythonExceptionHandling.DEFAULT", "modulename": "duckdb", "qualname": "PythonExceptionHandling.DEFAULT", "kind": "variable", "doc": "\n", "default_value": "<PythonExceptionHandling.DEFAULT: 0>"}, {"fullname": "duckdb.PythonExceptionHandling.RETURN_NULL", "modulename": "duckdb", "qualname": "PythonExceptionHandling.RETURN_NULL", "kind": "variable", "doc": "\n", "default_value": "<PythonExceptionHandling.RETURN_NULL: 1>"}, {"fullname": "duckdb.RenderMode", "modulename": "duckdb", "qualname": "RenderMode", "kind": "class", "doc": "Members:\n\nROWS\n\nCOLUMNS\n", "bases": "pybind11_builtins.pybind11_object"}, {"fullname": "duckdb.RenderMode.__init__", "modulename": "duckdb", "qualname": "RenderMode.__init__", "kind": "function", "doc": "__init__(self: _duckdb.RenderMode, value: typing.SupportsInt) -> None\n", "signature": "()"}, {"fullname": "duckdb.RenderMode.name", "modulename": "duckdb", "qualname": "RenderMode.name", "kind": "variable", "doc": "name(self: object, /) -> str\n"}, {"fullname": "duckdb.RenderMode.value", "modulename": "duckdb", "qualname": "RenderMode.value", "kind": "variable", "doc": "(arg0: _duckdb.RenderMode) -> int\n"}, {"fullname": "duckdb.RenderMode.ROWS", "modulename": "duckdb", "qualname": "RenderMode.ROWS", "kind": "variable", "doc": "\n", "default_value": "<RenderMode.ROWS: 0>"}, {"fullname": "duckdb.RenderMode.COLUMNS", "modulename": "duckdb", "qualname": "RenderMode.COLUMNS", "kind": "variable", "doc": "\n", "default_value": "<RenderMode.COLUMNS: 1>"}, {"fullname": "duckdb.SQLExpression", "modulename": "duckdb", "qualname": "SQLExpression", "kind": "function", "doc": "SQLExpression(expression: str) -> _duckdb.Expression\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.SequenceException", "modulename": "duckdb", "qualname": "SequenceException", "kind": "class", "doc": "Common base class for all non-exit exceptions.\n", "bases": "_duckdb.DatabaseError"}, {"fullname": "duckdb.SerializationException", "modulename": "duckdb", "qualname": "SerializationException", "kind": "class", "doc": "Common base class for all non-exit exceptions.\n", "bases": "_duckdb.OperationalError"}, {"fullname": "duckdb.ShortValue", "modulename": "duckdb", "qualname": "ShortValue", "kind": "class", "doc": "\n", "bases": "duckdb.value.constant.Value"}, {"fullname": "duckdb.ShortValue.__init__", "modulename": "duckdb", "qualname": "ShortValue.__init__", "kind": "function", "doc": "\n", "signature": "(object: Any)"}, {"fullname": "duckdb.StarExpression", "modulename": "duckdb", "qualname": "StarExpression", "kind": "function", "doc": "StarExpression(args, *kwargs)\nOverloaded function.\n\n<ol>\n<li>StarExpression(*, exclude: object = None) -> _duckdb.Expression</li>\n<li>StarExpression() -> _duckdb.Expression</li>\n</ol>\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.Statement", "modulename": "duckdb", "qualname": "Statement", "kind": "class", "doc": "\n", "bases": "pybind11_builtins.pybind11_object"}, {"fullname": "duckdb.Statement.__init__", "modulename": "duckdb", "qualname": "Statement.__init__", "kind": "function", "doc": "\n", "signature": "(*args, **kwargs)"}, {"fullname": "duckdb.Statement.type", "modulename": "duckdb", "qualname": "Statement.type", "kind": "variable", "doc": "(arg0: _duckdb.Statement) -> _duckdb.StatementType\n"}, {"fullname": "duckdb.Statement.query", "modulename": "duckdb", "qualname": "Statement.query", "kind": "variable", "doc": "(arg0: _duckdb.Statement) -> str\n"}, {"fullname": "duckdb.Statement.named_parameters", "modulename": "duckdb", "qualname": "Statement.named_parameters", "kind": "variable", "doc": "(arg0: _duckdb.Statement) -> set\n"}, {"fullname": "duckdb.Statement.expected_result_type", "modulename": "duckdb", "qualname": "Statement.expected_result_type", "kind": "variable", "doc": "(arg0: _duckdb.Statement) -> list\n"}, {"fullname": "duckdb.StatementType", "modulename": "duckdb", "qualname": "StatementType", "kind": "class", "doc": "Members:\n\nINVALID\n\nSELECT\n\nINSERT\n\nUPDATE\n\nCREATE\n\nDELETE\n\nPREPARE\n\nEXECUTE\n\nALTER\n\nTRANSACTION\n\nCOPY\n\nANALYZE\n\nVARIABLE_SET\n\nCREATE_FUNC\n\nEXPLAIN\n\nDROP\n\nEXPORT\n\nPRAGMA\n\nVACUUM\n\nCALL\n\nSET\n\nLOAD\n\nRELATION\n\nEXTENSION\n\nLOGICAL_PLAN\n\nATTACH\n\nDETACH\n\nMULTI\n\nCOPY_DATABASE\n\nMERGE_INTO\n", "bases": "pybind11_builtins.pybind11_object"}, {"fullname": "duckdb.StatementType.__init__", "modulename": "duckdb", "qualname": "StatementType.__init__", "kind": "function", "doc": "__init__(self: _duckdb.StatementType, value: typing.SupportsInt) -> None\n", "signature": "()"}, {"fullname": "duckdb.StatementType.name", "modulename": "duckdb", "qualname": "StatementType.name", "kind": "variable", "doc": "name(self: object, /) -> str\n"}, {"fullname": "duckdb.StatementType.value", "modulename": "duckdb", "qualname": "StatementType.value", "kind": "variable", "doc": "(arg0: _duckdb.StatementType) -> int\n"}, {"fullname": "duckdb.StatementType.INVALID", "modulename": "duckdb", "qualname": "StatementType.INVALID", "kind": "variable", "doc": "\n", "default_value": "<StatementType.INVALID: 0>"}, {"fullname": "duckdb.StatementType.SELECT", "modulename": "duckdb", "qualname": "StatementType.SELECT", "kind": "variable", "doc": "\n", "default_value": "<StatementType.SELECT: 1>"}, {"fullname": "duckdb.StatementType.INSERT", "modulename": "duckdb", "qualname": "StatementType.INSERT", "kind": "variable", "doc": "\n", "default_value": "<StatementType.INSERT: 2>"}, {"fullname": "duckdb.StatementType.UPDATE", "modulename": "duckdb", "qualname": "StatementType.UPDATE", "kind": "variable", "doc": "\n", "default_value": "<StatementType.UPDATE: 3>"}, {"fullname": "duckdb.StatementType.CREATE", "modulename": "duckdb", "qualname": "StatementType.CREATE", "kind": "variable", "doc": "\n", "default_value": "<StatementType.CREATE: 4>"}, {"fullname": "duckdb.StatementType.DELETE", "modulename": "duckdb", "qualname": "StatementType.DELETE", "kind": "variable", "doc": "\n", "default_value": "<StatementType.DELETE: 5>"}, {"fullname": "duckdb.StatementType.PREPARE", "modulename": "duckdb", "qualname": "StatementType.PREPARE", "kind": "variable", "doc": "\n", "default_value": "<StatementType.PREPARE: 6>"}, {"fullname": "duckdb.StatementType.EXECUTE", "modulename": "duckdb", "qualname": "StatementType.EXECUTE", "kind": "variable", "doc": "\n", "default_value": "<StatementType.EXECUTE: 7>"}, {"fullname": "duckdb.StatementType.ALTER", "modulename": "duckdb", "qualname": "StatementType.ALTER", "kind": "variable", "doc": "\n", "default_value": "<StatementType.ALTER: 8>"}, {"fullname": "duckdb.StatementType.TRANSACTION", "modulename": "duckdb", "qualname": "StatementType.TRANSACTION", "kind": "variable", "doc": "\n", "default_value": "<StatementType.TRANSACTION: 9>"}, {"fullname": "duckdb.StatementType.COPY", "modulename": "duckdb", "qualname": "StatementType.COPY", "kind": "variable", "doc": "\n", "default_value": "<StatementType.COPY: 10>"}, {"fullname": "duckdb.StatementType.ANALYZE", "modulename": "duckdb", "qualname": "StatementType.ANALYZE", "kind": "variable", "doc": "\n", "default_value": "<StatementType.ANALYZE: 11>"}, {"fullname": "duckdb.StatementType.VARIABLE_SET", "modulename": "duckdb", "qualname": "StatementType.VARIABLE_SET", "kind": "variable", "doc": "\n", "default_value": "<StatementType.VARIABLE_SET: 12>"}, {"fullname": "duckdb.StatementType.CREATE_FUNC", "modulename": "duckdb", "qualname": "StatementType.CREATE_FUNC", "kind": "variable", "doc": "\n", "default_value": "<StatementType.CREATE_FUNC: 13>"}, {"fullname": "duckdb.StatementType.EXPLAIN", "modulename": "duckdb", "qualname": "StatementType.EXPLAIN", "kind": "variable", "doc": "\n", "default_value": "<StatementType.EXPLAIN: 14>"}, {"fullname": "duckdb.StatementType.DROP", "modulename": "duckdb", "qualname": "StatementType.DROP", "kind": "variable", "doc": "\n", "default_value": "<StatementType.DROP: 15>"}, {"fullname": "duckdb.StatementType.EXPORT", "modulename": "duckdb", "qualname": "StatementType.EXPORT", "kind": "variable", "doc": "\n", "default_value": "<StatementType.EXPORT: 16>"}, {"fullname": "duckdb.StatementType.PRAGMA", "modulename": "duckdb", "qualname": "StatementType.PRAGMA", "kind": "variable", "doc": "\n", "default_value": "<StatementType.PRAGMA: 17>"}, {"fullname": "duckdb.StatementType.VACUUM", "modulename": "duckdb", "qualname": "StatementType.VACUUM", "kind": "variable", "doc": "\n", "default_value": "<StatementType.VACUUM: 18>"}, {"fullname": "duckdb.StatementType.CALL", "modulename": "duckdb", "qualname": "StatementType.CALL", "kind": "variable", "doc": "\n", "default_value": "<StatementType.CALL: 19>"}, {"fullname": "duckdb.StatementType.SET", "modulename": "duckdb", "qualname": "StatementType.SET", "kind": "variable", "doc": "\n", "default_value": "<StatementType.SET: 20>"}, {"fullname": "duckdb.StatementType.LOAD", "modulename": "duckdb", "qualname": "StatementType.LOAD", "kind": "variable", "doc": "\n", "default_value": "<StatementType.LOAD: 21>"}, {"fullname": "duckdb.StatementType.RELATION", "modulename": "duckdb", "qualname": "StatementType.RELATION", "kind": "variable", "doc": "\n", "default_value": "<StatementType.RELATION: 22>"}, {"fullname": "duckdb.StatementType.EXTENSION", "modulename": "duckdb", "qualname": "StatementType.EXTENSION", "kind": "variable", "doc": "\n", "default_value": "<StatementType.EXTENSION: 23>"}, {"fullname": "duckdb.StatementType.LOGICAL_PLAN", "modulename": "duckdb", "qualname": "StatementType.LOGICAL_PLAN", "kind": "variable", "doc": "\n", "default_value": "<StatementType.LOGICAL_PLAN: 24>"}, {"fullname": "duckdb.StatementType.ATTACH", "modulename": "duckdb", "qualname": "StatementType.ATTACH", "kind": "variable", "doc": "\n", "default_value": "<StatementType.ATTACH: 25>"}, {"fullname": "duckdb.StatementType.DETACH", "modulename": "duckdb", "qualname": "StatementType.DETACH", "kind": "variable", "doc": "\n", "default_value": "<StatementType.DETACH: 26>"}, {"fullname": "duckdb.StatementType.MULTI", "modulename": "duckdb", "qualname": "StatementType.MULTI", "kind": "variable", "doc": "\n", "default_value": "<StatementType.MULTI: 27>"}, {"fullname": "duckdb.StatementType.COPY_DATABASE", "modulename": "duckdb", "qualname": "StatementType.COPY_DATABASE", "kind": "variable", "doc": "\n", "default_value": "<StatementType.COPY_DATABASE: 28>"}, {"fullname": "duckdb.StatementType.MERGE_INTO", "modulename": "duckdb", "qualname": "StatementType.MERGE_INTO", "kind": "variable", "doc": "\n", "default_value": "<StatementType.MERGE_INTO: 30>"}, {"fullname": "duckdb.StringValue", "modulename": "duckdb", "qualname": "StringValue", "kind": "class", "doc": "\n", "bases": "duckdb.value.constant.Value"}, {"fullname": "duckdb.StringValue.__init__", "modulename": "duckdb", "qualname": "StringValue.__init__", "kind": "function", "doc": "\n", "signature": "(object: Any)"}, {"fullname": "duckdb.StructValue", "modulename": "duckdb", "qualname": "StructValue", "kind": "class", "doc": "\n", "bases": "duckdb.value.constant.Value"}, {"fullname": "duckdb.StructValue.__init__", "modulename": "duckdb", "qualname": "StructValue.__init__", "kind": "function", "doc": "\n", "signature": "(object: Any, children: dict[str, _duckdb._sqltypes.DuckDBPyType])"}, {"fullname": "duckdb.SyntaxException", "modulename": "duckdb", "qualname": "SyntaxException", "kind": "class", "doc": "Common base class for all non-exit exceptions.\n", "bases": "_duckdb.ProgrammingError"}, {"fullname": "duckdb.TimeTimeZoneValue", "modulename": "duckdb", "qualname": "TimeTimeZoneValue", "kind": "class", "doc": "\n", "bases": "duckdb.value.constant.Value"}, {"fullname": "duckdb.TimeTimeZoneValue.__init__", "modulename": "duckdb", "qualname": "TimeTimeZoneValue.__init__", "kind": "function", "doc": "\n", "signature": "(object: Any)"}, {"fullname": "duckdb.TimeValue", "modulename": "duckdb", "qualname": "TimeValue", "kind": "class", "doc": "\n", "bases": "duckdb.value.constant.Value"}, {"fullname": "duckdb.TimeValue.__init__", "modulename": "duckdb", "qualname": "TimeValue.__init__", "kind": "function", "doc": "\n", "signature": "(object: Any)"}, {"fullname": "duckdb.TimestampMilisecondValue", "modulename": "duckdb", "qualname": "TimestampMilisecondValue", "kind": "class", "doc": "\n", "bases": "duckdb.value.constant.Value"}, {"fullname": "duckdb.TimestampMilisecondValue.__init__", "modulename": "duckdb", "qualname": "TimestampMilisecondValue.__init__", "kind": "function", "doc": "\n", "signature": "(object: Any)"}, {"fullname": "duckdb.TimestampNanosecondValue", "modulename": "duckdb", "qualname": "TimestampNanosecondValue", "kind": "class", "doc": "\n", "bases": "duckdb.value.constant.Value"}, {"fullname": "duckdb.TimestampNanosecondValue.__init__", "modulename": "duckdb", "qualname": "TimestampNanosecondValue.__init__", "kind": "function", "doc": "\n", "signature": "(object: Any)"}, {"fullname": "duckdb.TimestampSecondValue", "modulename": "duckdb", "qualname": "TimestampSecondValue", "kind": "class", "doc": "\n", "bases": "duckdb.value.constant.Value"}, {"fullname": "duckdb.TimestampSecondValue.__init__", "modulename": "duckdb", "qualname": "TimestampSecondValue.__init__", "kind": "function", "doc": "\n", "signature": "(object: Any)"}, {"fullname": "duckdb.TimestampTimeZoneValue", "modulename": "duckdb", "qualname": "TimestampTimeZoneValue", "kind": "class", "doc": "\n", "bases": "duckdb.value.constant.Value"}, {"fullname": "duckdb.TimestampTimeZoneValue.__init__", "modulename": "duckdb", "qualname": "TimestampTimeZoneValue.__init__", "kind": "function", "doc": "\n", "signature": "(object: Any)"}, {"fullname": "duckdb.TimestampValue", "modulename": "duckdb", "qualname": "TimestampValue", "kind": "class", "doc": "\n", "bases": "duckdb.value.constant.Value"}, {"fullname": "duckdb.TimestampValue.__init__", "modulename": "duckdb", "qualname": "TimestampValue.__init__", "kind": "function", "doc": "\n", "signature": "(object: Any)"}, {"fullname": "duckdb.TransactionException", "modulename": "duckdb", "qualname": "TransactionException", "kind": "class", "doc": "Common base class for all non-exit exceptions.\n", "bases": "_duckdb.OperationalError"}, {"fullname": "duckdb.TypeMismatchException", "modulename": "duckdb", "qualname": "TypeMismatchException", "kind": "class", "doc": "Common base class for all non-exit exceptions.\n", "bases": "_duckdb.DataError"}, {"fullname": "duckdb.UUIDValue", "modulename": "duckdb", "qualname": "UUIDValue", "kind": "class", "doc": "\n", "bases": "duckdb.value.constant.Value"}, {"fullname": "duckdb.UUIDValue.__init__", "modulename": "duckdb", "qualname": "UUIDValue.__init__", "kind": "function", "doc": "\n", "signature": "(object: Any)"}, {"fullname": "duckdb.UnionType", "modulename": "duckdb", "qualname": "UnionType", "kind": "class", "doc": "\n", "bases": "duckdb.value.constant.Value"}, {"fullname": "duckdb.UnionType.__init__", "modulename": "duckdb", "qualname": "UnionType.__init__", "kind": "function", "doc": "\n", "signature": "(object: Any, members: dict[str, _duckdb._sqltypes.DuckDBPyType])"}, {"fullname": "duckdb.UnsignedBinaryValue", "modulename": "duckdb", "qualname": "UnsignedBinaryValue", "kind": "class", "doc": "\n", "bases": "duckdb.value.constant.Value"}, {"fullname": "duckdb.UnsignedBinaryValue.__init__", "modulename": "duckdb", "qualname": "UnsignedBinaryValue.__init__", "kind": "function", "doc": "\n", "signature": "(object: Any)"}, {"fullname": "duckdb.UnsignedHugeIntegerValue", "modulename": "duckdb", "qualname": "UnsignedHugeIntegerValue", "kind": "class", "doc": "\n", "bases": "duckdb.value.constant.Value"}, {"fullname": "duckdb.UnsignedHugeIntegerValue.__init__", "modulename": "duckdb", "qualname": "UnsignedHugeIntegerValue.__init__", "kind": "function", "doc": "\n", "signature": "(object: Any)"}, {"fullname": "duckdb.UnsignedIntegerValue", "modulename": "duckdb", "qualname": "UnsignedIntegerValue", "kind": "class", "doc": "\n", "bases": "duckdb.value.constant.Value"}, {"fullname": "duckdb.UnsignedIntegerValue.__init__", "modulename": "duckdb", "qualname": "UnsignedIntegerValue.__init__", "kind": "function", "doc": "\n", "signature": "(object: Any)"}, {"fullname": "duckdb.UnsignedLongValue", "modulename": "duckdb", "qualname": "UnsignedLongValue", "kind": "class", "doc": "\n", "bases": "duckdb.value.constant.Value"}, {"fullname": "duckdb.UnsignedLongValue.__init__", "modulename": "duckdb", "qualname": "UnsignedLongValue.__init__", "kind": "function", "doc": "\n", "signature": "(object: Any)"}, {"fullname": "duckdb.UnsignedShortValue", "modulename": "duckdb", "qualname": "UnsignedShortValue", "kind": "class", "doc": "\n", "bases": "duckdb.value.constant.Value"}, {"fullname": "duckdb.UnsignedShortValue.__init__", "modulename": "duckdb", "qualname": "UnsignedShortValue.__init__", "kind": "function", "doc": "\n", "signature": "(object: Any)"}, {"fullname": "duckdb.Value", "modulename": "duckdb", "qualname": "Value", "kind": "class", "doc": "\n"}, {"fullname": "duckdb.Value.__init__", "modulename": "duckdb", "qualname": "Value.__init__", "kind": "function", "doc": "\n", "signature": "(object: Any, type: _duckdb._sqltypes.DuckDBPyType)"}, {"fullname": "duckdb.Value.object", "modulename": "duckdb", "qualname": "Value.object", "kind": "variable", "doc": "\n"}, {"fullname": "duckdb.Value.type", "modulename": "duckdb", "qualname": "Value.type", "kind": "variable", "doc": "\n"}, {"fullname": "duckdb.Warning", "modulename": "duckdb", "qualname": "Warning", "kind": "class", "doc": "Common base class for all non-exit exceptions.\n", "bases": "builtins.Exception"}, {"fullname": "duckdb.aggregate", "modulename": "duckdb", "qualname": "aggregate", "kind": "function", "doc": "aggregate(df: pandas.DataFrame, aggr_expr: object, group_expr: str = '', *, connection: duckdb.DuckDBPyConnection = None) -> _duckdb.DuckDBPyRelation\n\nCompute the aggregate aggr_expr by the optional groups group_expr on the relation\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.alias", "modulename": "duckdb", "qualname": "alias", "kind": "function", "doc": "alias(df: pandas.DataFrame, alias: str, *, connection: duckdb.DuckDBPyConnection = None) -> _duckdb.DuckDBPyRelation\n\nRename the relation object to new alias\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.apilevel", "modulename": "duckdb", "qualname": "apilevel", "kind": "variable", "doc": "\n", "default_value": "'2.0'"}, {"fullname": "duckdb.append", "modulename": "duckdb", "qualname": "append", "kind": "function", "doc": "append(table_name: str, df: pandas.DataFrame, *, by_name: bool = False, connection: duckdb.DuckDBPyConnection = None) -> duckdb.DuckDBPyConnection\n\nAppend the passed DataFrame to the named table\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.array_type", "modulename": "duckdb", "qualname": "array_type", "kind": "function", "doc": "array_type(type: _duckdb._sqltypes.DuckDBPyType, size: typing.SupportsInt, *, connection: duckdb.DuckDBPyConnection = None) -> _duckdb._sqltypes.DuckDBPyType\n\nCreate an array type object of 'type'\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.arrow", "modulename": "duckdb", "qualname": "arrow", "kind": "function", "doc": "arrow(args, *kwargs)\nOverloaded function.\n\n<ol>\n<li>arrow(rows_per_batch: typing.SupportsInt = 1000000, *, connection: duckdb.DuckDBPyConnection = None) -> pyarrow.lib.RecordBatchReader</li>\n</ol>\n\nFetch an Arrow RecordBatchReader following execute()\n\n<ol start=\"2\">\n<li>arrow(rows_per_batch: typing.SupportsInt = 1000000, *, connection: duckdb.DuckDBPyConnection = None) -> pyarrow.lib.Table</li>\n</ol>\n\nFetch a result as Arrow table following execute()\n\n<ol start=\"3\">\n<li>arrow(arrow_object: object, *, connection: duckdb.DuckDBPyConnection = None) -> _duckdb.DuckDBPyRelation</li>\n</ol>\n\nCreate a relation object from an Arrow object\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.begin", "modulename": "duckdb", "qualname": "begin", "kind": "function", "doc": "begin(*, connection: duckdb.DuckDBPyConnection = None) -> duckdb.DuckDBPyConnection\n\nStart a new transaction\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.checkpoint", "modulename": "duckdb", "qualname": "checkpoint", "kind": "function", "doc": "checkpoint(*, connection: duckdb.DuckDBPyConnection = None) -> duckdb.DuckDBPyConnection\n\nSynchronizes data in the write-ahead log (WAL) to the database data file (no-op for in-memory connections)\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.close", "modulename": "duckdb", "qualname": "close", "kind": "function", "doc": "close(*, connection: duckdb.DuckDBPyConnection = None) -> None\n\nClose the connection\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.commit", "modulename": "duckdb", "qualname": "commit", "kind": "function", "doc": "commit(*, connection: duckdb.DuckDBPyConnection = None) -> duckdb.DuckDBPyConnection\n\nCommit changes performed within a transaction\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.connect", "modulename": "duckdb", "qualname": "connect", "kind": "function", "doc": "connect(database: object = ':memory:', read_only: bool = False, config: dict = None) -> duckdb.DuckDBPyConnection\n\nCreate a DuckDB database instance. Can take a database file name to read/write persistent data and a read_only flag if no changes are desired\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.create_function", "modulename": "duckdb", "qualname": "create_function", "kind": "function", "doc": "create_function(name: str, function: collections.abc.Callable, parameters: object = None, return_type: _duckdb._sqltypes.DuckDBPyType = None, *, type: _duckdb._func.PythonUDFType = <PythonUDFType.NATIVE: 0>, null_handling: _duckdb._func.FunctionNullHandling = <FunctionNullHandling.DEFAULT: 0>, exception_handling: _duckdb.PythonExceptionHandling = <PythonExceptionHandling.DEFAULT: 0>, side_effects: bool = False, connection: duckdb.DuckDBPyConnection = None) -> duckdb.DuckDBPyConnection\n\nCreate a DuckDB function out of the passing in Python function so it can be used in queries\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.cursor", "modulename": "duckdb", "qualname": "cursor", "kind": "function", "doc": "cursor(*, connection: duckdb.DuckDBPyConnection = None) -> duckdb.DuckDBPyConnection\n\nCreate a duplicate of the current connection\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.decimal_type", "modulename": "duckdb", "qualname": "decimal_type", "kind": "function", "doc": "decimal_type(width: typing.SupportsInt, scale: typing.SupportsInt, *, connection: duckdb.DuckDBPyConnection = None) -> _duckdb._sqltypes.DuckDBPyType\n\nCreate a decimal type with 'width' and 'scale'\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.default_connection", "modulename": "duckdb", "qualname": "default_connection", "kind": "function", "doc": "default_connection() -> duckdb.DuckDBPyConnection\n\nRetrieve the connection currently registered as the default to be used by the module\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.description", "modulename": "duckdb", "qualname": "description", "kind": "function", "doc": "description(*, connection: duckdb.DuckDBPyConnection = None) -> typing.Optional[list]\n\nGet result set attributes, mainly column names\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.df", "modulename": "duckdb", "qualname": "df", "kind": "function", "doc": "df(args, *kwargs)\nOverloaded function.\n\n<ol>\n<li>df(*, date_as_object: bool = False, connection: duckdb.DuckDBPyConnection = None) -> pandas.DataFrame</li>\n</ol>\n\nFetch a result as DataFrame following execute()\n\n<ol start=\"2\">\n<li>df(*, date_as_object: bool = False, connection: duckdb.DuckDBPyConnection = None) -> pandas.DataFrame</li>\n</ol>\n\nFetch a result as DataFrame following execute()\n\n<ol start=\"3\">\n<li>df(df: pandas.DataFrame, *, connection: duckdb.DuckDBPyConnection = None) -> _duckdb.DuckDBPyRelation</li>\n</ol>\n\nCreate a relation object from the DataFrame df\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.distinct", "modulename": "duckdb", "qualname": "distinct", "kind": "function", "doc": "distinct(df: pandas.DataFrame, *, connection: duckdb.DuckDBPyConnection = None) -> _duckdb.DuckDBPyRelation\n\nRetrieve distinct rows from this relation object\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.dtype", "modulename": "duckdb", "qualname": "dtype", "kind": "function", "doc": "dtype(type_str: str, *, connection: duckdb.DuckDBPyConnection = None) -> _duckdb._sqltypes.DuckDBPyType\n\nCreate a type object by parsing the 'type_str' string\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.duplicate", "modulename": "duckdb", "qualname": "duplicate", "kind": "function", "doc": "duplicate(*, connection: duckdb.DuckDBPyConnection = None) -> duckdb.DuckDBPyConnection\n\nCreate a duplicate of the current connection\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.enum_type", "modulename": "duckdb", "qualname": "enum_type", "kind": "function", "doc": "enum_type(name: str, type: _duckdb._sqltypes.DuckDBPyType, values: list, *, connection: duckdb.DuckDBPyConnection = None) -> _duckdb._sqltypes.DuckDBPyType\n\nCreate an enum type of underlying 'type', consisting of the list of 'values'\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.execute", "modulename": "duckdb", "qualname": "execute", "kind": "function", "doc": "execute(query: object, parameters: object = None, *, connection: duckdb.DuckDBPyConnection = None) -> duckdb.DuckDBPyConnection\n\nExecute the given SQL query, optionally using prepared statements with parameters set\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.executemany", "modulename": "duckdb", "qualname": "executemany", "kind": "function", "doc": "executemany(query: object, parameters: object = None, *, connection: duckdb.DuckDBPyConnection = None) -> duckdb.DuckDBPyConnection\n\nExecute the given prepared statement multiple times using the list of parameter sets in parameters\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.extract_statements", "modulename": "duckdb", "qualname": "extract_statements", "kind": "function", "doc": "extract_statements(query: str, *, connection: duckdb.DuckDBPyConnection = None) -> list\n\nParse the query string and extract the Statement object(s) produced\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.fetch_arrow_table", "modulename": "duckdb", "qualname": "fetch_arrow_table", "kind": "function", "doc": "fetch_arrow_table(rows_per_batch: typing.SupportsInt = 1000000, *, connection: duckdb.DuckDBPyConnection = None) -> pyarrow.lib.Table\n\nFetch a result as Arrow table following execute()\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.fetch_df", "modulename": "duckdb", "qualname": "fetch_df", "kind": "function", "doc": "fetch_df(*, date_as_object: bool = False, connection: duckdb.DuckDBPyConnection = None) -> pandas.DataFrame\n\nFetch a result as DataFrame following execute()\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.fetch_df_chunk", "modulename": "duckdb", "qualname": "fetch_df_chunk", "kind": "function", "doc": "fetch_df_chunk(vectors_per_chunk: typing.SupportsInt = 1, *, date_as_object: bool = False, connection: duckdb.DuckDBPyConnection = None) -> pandas.DataFrame\n\nFetch a chunk of the result as DataFrame following execute()\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.fetch_record_batch", "modulename": "duckdb", "qualname": "fetch_record_batch", "kind": "function", "doc": "fetch_record_batch(rows_per_batch: typing.SupportsInt = 1000000, *, connection: duckdb.DuckDBPyConnection = None) -> pyarrow.lib.RecordBatchReader\n\nFetch an Arrow RecordBatchReader following execute()\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.fetchall", "modulename": "duckdb", "qualname": "fetchall", "kind": "function", "doc": "fetchall(*, connection: duckdb.DuckDBPyConnection = None) -> list\n\nFetch all rows from a result following execute\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.fetchdf", "modulename": "duckdb", "qualname": "fetchdf", "kind": "function", "doc": "fetchdf(*, date_as_object: bool = False, connection: duckdb.DuckDBPyConnection = None) -> pandas.DataFrame\n\nFetch a result as DataFrame following execute()\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.fetchmany", "modulename": "duckdb", "qualname": "fetchmany", "kind": "function", "doc": "fetchmany(size: typing.SupportsInt = 1, *, connection: duckdb.DuckDBPyConnection = None) -> list\n\nFetch the next set of rows from a result following execute\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.fetchnumpy", "modulename": "duckdb", "qualname": "fetchnumpy", "kind": "function", "doc": "fetchnumpy(*, connection: duckdb.DuckDBPyConnection = None) -> dict\n\nFetch a result as list of NumPy arrays following execute\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.fetchone", "modulename": "duckdb", "qualname": "fetchone", "kind": "function", "doc": "fetchone(*, connection: duckdb.DuckDBPyConnection = None) -> typing.Optional[tuple]\n\nFetch a single row from a result following execute\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.filesystem_is_registered", "modulename": "duckdb", "qualname": "filesystem_is_registered", "kind": "function", "doc": "filesystem_is_registered(name: str, *, connection: duckdb.DuckDBPyConnection = None) -> bool\n\nCheck if a filesystem with the provided name is currently registered\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.filter", "modulename": "duckdb", "qualname": "filter", "kind": "function", "doc": "filter(df: pandas.DataFrame, filter_expr: object, *, connection: duckdb.DuckDBPyConnection = None) -> _duckdb.DuckDBPyRelation\n\nFilter the relation object by the filter in filter_expr\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.from_arrow", "modulename": "duckdb", "qualname": "from_arrow", "kind": "function", "doc": "from_arrow(arrow_object: object, *, connection: duckdb.DuckDBPyConnection = None) -> _duckdb.DuckDBPyRelation\n\nCreate a relation object from an Arrow object\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.from_csv_auto", "modulename": "duckdb", "qualname": "from_csv_auto", "kind": "function", "doc": "from_csv_auto(path_or_buffer: object, **kwargs) -> _duckdb.DuckDBPyRelation\n\nCreate a relation object from the CSV file in 'name'\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.from_df", "modulename": "duckdb", "qualname": "from_df", "kind": "function", "doc": "from_df(df: pandas.DataFrame, *, connection: duckdb.DuckDBPyConnection = None) -> _duckdb.DuckDBPyRelation\n\nCreate a relation object from the DataFrame in df\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.from_parquet", "modulename": "duckdb", "qualname": "from_parquet", "kind": "function", "doc": "from_parquet(args, *kwargs)\nOverloaded function.\n\n<ol>\n<li>from_parquet(file_glob: str, binary_as_string: bool = False, *, file_row_number: bool = False, filename: bool = False, hive_partitioning: bool = False, union_by_name: bool = False, compression: object = None, connection: duckdb.DuckDBPyConnection = None) -> _duckdb.DuckDBPyRelation</li>\n</ol>\n\nCreate a relation object from the Parquet files in file_glob\n\n<ol start=\"2\">\n<li>from_parquet(file_globs: collections.abc.Sequence[str], binary_as_string: bool = False, *, file_row_number: bool = False, filename: bool = False, hive_partitioning: bool = False, union_by_name: bool = False, compression: object = None, connection: duckdb.DuckDBPyConnection = None) -> _duckdb.DuckDBPyRelation</li>\n</ol>\n\nCreate a relation object from the Parquet files in file_globs\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.from_query", "modulename": "duckdb", "qualname": "from_query", "kind": "function", "doc": "from_query(query: object, *, alias: str = '', params: object = None, connection: duckdb.DuckDBPyConnection = None) -> _duckdb.DuckDBPyRelation\n\nRun a SQL query. If it is a SELECT statement, create a relation object from the given SQL query, otherwise run the query as-is.\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.get_table_names", "modulename": "duckdb", "qualname": "get_table_names", "kind": "function", "doc": "get_table_names(query: str, *, qualified: bool = False, connection: duckdb.DuckDBPyConnection = None) -> set[str]\n\nExtract the required table names from a query\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.install_extension", "modulename": "duckdb", "qualname": "install_extension", "kind": "function", "doc": "install_extension(extension: str, *, force_install: bool = False, repository: object = None, repository_url: object = None, version: object = None, connection: duckdb.DuckDBPyConnection = None) -> None\n\nInstall an extension by name, with an optional version and/or repository to get the extension from\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.interrupt", "modulename": "duckdb", "qualname": "interrupt", "kind": "function", "doc": "interrupt(*, connection: duckdb.DuckDBPyConnection = None) -> None\n\nInterrupt pending operations\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.limit", "modulename": "duckdb", "qualname": "limit", "kind": "function", "doc": "limit(df: pandas.DataFrame, n: typing.SupportsInt, offset: typing.SupportsInt = 0, *, connection: duckdb.DuckDBPyConnection = None) -> _duckdb.DuckDBPyRelation\n\nOnly retrieve the first n rows from this relation object, starting at offset\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.list_filesystems", "modulename": "duckdb", "qualname": "list_filesystems", "kind": "function", "doc": "list_filesystems(*, connection: duckdb.DuckDBPyConnection = None) -> list\n\nList registered filesystems, including builtin ones\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.list_type", "modulename": "duckdb", "qualname": "list_type", "kind": "function", "doc": "list_type(type: _duckdb._sqltypes.DuckDBPyType, *, connection: duckdb.DuckDBPyConnection = None) -> _duckdb._sqltypes.DuckDBPyType\n\nCreate a list type object of 'type'\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.load_extension", "modulename": "duckdb", "qualname": "load_extension", "kind": "function", "doc": "load_extension(extension: str, *, connection: duckdb.DuckDBPyConnection = None) -> None\n\nLoad an installed extension\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.map_type", "modulename": "duckdb", "qualname": "map_type", "kind": "function", "doc": "map_type(key: _duckdb._sqltypes.DuckDBPyType, value: _duckdb._sqltypes.DuckDBPyType, *, connection: duckdb.DuckDBPyConnection = None) -> _duckdb._sqltypes.DuckDBPyType\n\nCreate a map type object from 'key_type' and 'value_type'\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.order", "modulename": "duckdb", "qualname": "order", "kind": "function", "doc": "order(df: pandas.DataFrame, order_expr: str, *, connection: duckdb.DuckDBPyConnection = None) -> _duckdb.DuckDBPyRelation\n\nReorder the relation object by order_expr\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.paramstyle", "modulename": "duckdb", "qualname": "paramstyle", "kind": "variable", "doc": "\n", "default_value": "'qmark'"}, {"fullname": "duckdb.pl", "modulename": "duckdb", "qualname": "pl", "kind": "function", "doc": "pl(rows_per_batch: typing.SupportsInt = 1000000, *, lazy: bool = False, connection: duckdb.DuckDBPyConnection = None) -> duckdb::PolarsDataFrame\n\nFetch a result as Polars DataFrame following execute()\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.project", "modulename": "duckdb", "qualname": "project", "kind": "function", "doc": "project(df: pandas.DataFrame, *args, groups: str = '', connection: duckdb.DuckDBPyConnection = None) -> _duckdb.DuckDBPyRelation\n\nProject the relation object by the projection in project_expr\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.query", "modulename": "duckdb", "qualname": "query", "kind": "function", "doc": "query(query: object, *, alias: str = '', params: object = None, connection: duckdb.DuckDBPyConnection = None) -> _duckdb.DuckDBPyRelation\n\nRun a SQL query. If it is a SELECT statement, create a relation object from the given SQL query, otherwise run the query as-is.\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.query_df", "modulename": "duckdb", "qualname": "query_df", "kind": "function", "doc": "query_df(df: pandas.DataFrame, virtual_table_name: str, sql_query: str, *, connection: duckdb.DuckDBPyConnection = None) -> _duckdb.DuckDBPyRelation\n\nRun the given SQL query in sql_query on the view named virtual_table_name that refers to the relation object\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.query_progress", "modulename": "duckdb", "qualname": "query_progress", "kind": "function", "doc": "query_progress(*, connection: duckdb.DuckDBPyConnection = None) -> float\n\nQuery progress of pending operation\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.read_csv", "modulename": "duckdb", "qualname": "read_csv", "kind": "function", "doc": "read_csv(path_or_buffer: object, **kwargs) -> _duckdb.DuckDBPyRelation\n\nCreate a relation object from the CSV file in 'name'\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.read_json", "modulename": "duckdb", "qualname": "read_json", "kind": "function", "doc": "read_json(path_or_buffer: object, *, columns: typing.Optional[object] = None, sample_size: typing.Optional[object] = None, maximum_depth: typing.Optional[object] = None, records: typing.Optional[str] = None, format: typing.Optional[str] = None, date_format: typing.Optional[object] = None, timestamp_format: typing.Optional[object] = None, compression: typing.Optional[object] = None, maximum_object_size: typing.Optional[object] = None, ignore_errors: typing.Optional[object] = None, convert_strings_to_integers: typing.Optional[object] = None, field_appearance_threshold: typing.Optional[object] = None, map_inference_threshold: typing.Optional[object] = None, maximum_sample_files: typing.Optional[object] = None, filename: typing.Optional[object] = None, hive_partitioning: typing.Optional[object] = None, union_by_name: typing.Optional[object] = None, hive_types: typing.Optional[object] = None, hive_types_autocast: typing.Optional[object] = None, connection: duckdb.DuckDBPyConnection = None) -> _duckdb.DuckDBPyRelation\n\nCreate a relation object from the JSON file in 'name'\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.read_parquet", "modulename": "duckdb", "qualname": "read_parquet", "kind": "function", "doc": "read_parquet(args, *kwargs)\nOverloaded function.\n\n<ol>\n<li>read_parquet(file_glob: str, binary_as_string: bool = False, *, file_row_number: bool = False, filename: bool = False, hive_partitioning: bool = False, union_by_name: bool = False, compression: object = None, connection: duckdb.DuckDBPyConnection = None) -> _duckdb.DuckDBPyRelation</li>\n</ol>\n\nCreate a relation object from the Parquet files in file_glob\n\n<ol start=\"2\">\n<li>read_parquet(file_globs: collections.abc.Sequence[str], binary_as_string: bool = False, *, file_row_number: bool = False, filename: bool = False, hive_partitioning: bool = False, union_by_name: bool = False, compression: object = None, connection: duckdb.DuckDBPyConnection = None) -> _duckdb.DuckDBPyRelation</li>\n</ol>\n\nCreate a relation object from the Parquet files in file_globs\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.register", "modulename": "duckdb", "qualname": "register", "kind": "function", "doc": "register(view_name: str, python_object: object, *, connection: duckdb.DuckDBPyConnection = None) -> duckdb.DuckDBPyConnection\n\nRegister the passed Python Object value for querying with a view\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.register_filesystem", "modulename": "duckdb", "qualname": "register_filesystem", "kind": "function", "doc": "register_filesystem(filesystem: fsspec.AbstractFileSystem, *, connection: duckdb.DuckDBPyConnection = None) -> None\n\nRegister a fsspec compliant filesystem\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.remove_function", "modulename": "duckdb", "qualname": "remove_function", "kind": "function", "doc": "remove_function(name: str, *, connection: duckdb.DuckDBPyConnection = None) -> duckdb.DuckDBPyConnection\n\nRemove a previously created function\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.rollback", "modulename": "duckdb", "qualname": "rollback", "kind": "function", "doc": "rollback(*, connection: duckdb.DuckDBPyConnection = None) -> duckdb.DuckDBPyConnection\n\nRoll back changes performed within a transaction\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.row_type", "modulename": "duckdb", "qualname": "row_type", "kind": "function", "doc": "row_type(fields: object, *, connection: duckdb.DuckDBPyConnection = None) -> _duckdb._sqltypes.DuckDBPyType\n\nCreate a struct type object from 'fields'\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.rowcount", "modulename": "duckdb", "qualname": "rowcount", "kind": "function", "doc": "rowcount(*, connection: duckdb.DuckDBPyConnection = None) -> int\n\nGet result set row count\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.set_default_connection", "modulename": "duckdb", "qualname": "set_default_connection", "kind": "function", "doc": "set_default_connection(connection: duckdb.DuckDBPyConnection) -> None\n\nRegister the provided connection as the default to be used by the module\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.sql", "modulename": "duckdb", "qualname": "sql", "kind": "function", "doc": "sql(query: object, *, alias: str = '', params: object = None, connection: duckdb.DuckDBPyConnection = None) -> _duckdb.DuckDBPyRelation\n\nRun a SQL query. If it is a SELECT statement, create a relation object from the given SQL query, otherwise run the query as-is.\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.sqltype", "modulename": "duckdb", "qualname": "sqltype", "kind": "function", "doc": "sqltype(type_str: str, *, connection: duckdb.DuckDBPyConnection = None) -> _duckdb._sqltypes.DuckDBPyType\n\nCreate a type object by parsing the 'type_str' string\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.string_type", "modulename": "duckdb", "qualname": "string_type", "kind": "function", "doc": "string_type(collation: str = '', *, connection: duckdb.DuckDBPyConnection = None) -> _duckdb._sqltypes.DuckDBPyType\n\nCreate a string type with an optional collation\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.struct_type", "modulename": "duckdb", "qualname": "struct_type", "kind": "function", "doc": "struct_type(fields: object, *, connection: duckdb.DuckDBPyConnection = None) -> _duckdb._sqltypes.DuckDBPyType\n\nCreate a struct type object from 'fields'\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.table", "modulename": "duckdb", "qualname": "table", "kind": "function", "doc": "table(table_name: str, *, connection: duckdb.DuckDBPyConnection = None) -> _duckdb.DuckDBPyRelation\n\nCreate a relation object for the named table\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.table_function", "modulename": "duckdb", "qualname": "table_function", "kind": "function", "doc": "table_function(name: str, parameters: object = None, *, connection: duckdb.DuckDBPyConnection = None) -> _duckdb.DuckDBPyRelation\n\nCreate a relation object from the named table function with given parameters\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.tf", "modulename": "duckdb", "qualname": "tf", "kind": "function", "doc": "tf(*, connection: duckdb.DuckDBPyConnection = None) -> dict\n\nFetch a result as dict of TensorFlow Tensors following execute()\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.threadsafety", "modulename": "duckdb", "qualname": "threadsafety", "kind": "variable", "doc": "\n", "default_value": "1"}, {"fullname": "duckdb.token_type", "modulename": "duckdb", "qualname": "token_type", "kind": "class", "doc": "Members:\n\nidentifier\n\nnumeric_const\n\nstring_const\n\noperator\n\nkeyword\n\ncomment\n", "bases": "pybind11_builtins.pybind11_object"}, {"fullname": "duckdb.token_type.__init__", "modulename": "duckdb", "qualname": "token_type.__init__", "kind": "function", "doc": "__init__(self: _duckdb.token_type, value: typing.SupportsInt) -> None\n", "signature": "()"}, {"fullname": "duckdb.token_type.name", "modulename": "duckdb", "qualname": "token_type.name", "kind": "variable", "doc": "name(self: object, /) -> str\n"}, {"fullname": "duckdb.token_type.value", "modulename": "duckdb", "qualname": "token_type.value", "kind": "variable", "doc": "(arg0: _duckdb.token_type) -> int\n"}, {"fullname": "duckdb.token_type.identifier", "modulename": "duckdb", "qualname": "token_type.identifier", "kind": "variable", "doc": "\n", "default_value": "<token_type.identifier: 0>"}, {"fullname": "duckdb.token_type.numeric_const", "modulename": "duckdb", "qualname": "token_type.numeric_const", "kind": "variable", "doc": "\n", "default_value": "<token_type.numeric_const: 1>"}, {"fullname": "duckdb.token_type.string_const", "modulename": "duckdb", "qualname": "token_type.string_const", "kind": "variable", "doc": "\n", "default_value": "<token_type.string_const: 2>"}, {"fullname": "duckdb.token_type.operator", "modulename": "duckdb", "qualname": "token_type.operator", "kind": "variable", "doc": "\n", "default_value": "<token_type.operator: 3>"}, {"fullname": "duckdb.token_type.keyword", "modulename": "duckdb", "qualname": "token_type.keyword", "kind": "variable", "doc": "\n", "default_value": "<token_type.keyword: 4>"}, {"fullname": "duckdb.token_type.comment", "modulename": "duckdb", "qualname": "token_type.comment", "kind": "variable", "doc": "\n", "default_value": "<token_type.comment: 5>"}, {"fullname": "duckdb.tokenize", "modulename": "duckdb", "qualname": "tokenize", "kind": "function", "doc": "tokenize(query: str) -> list\n\nTokenizes a SQL string, returning a list of (position, type) tuples that can be used for e.g., syntax highlighting\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.torch", "modulename": "duckdb", "qualname": "torch", "kind": "function", "doc": "torch(*, connection: duckdb.DuckDBPyConnection = None) -> dict\n\nFetch a result as dict of PyTorch Tensors following execute()\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.type", "modulename": "duckdb", "qualname": "type", "kind": "function", "doc": "type(type_str: str, *, connection: duckdb.DuckDBPyConnection = None) -> _duckdb._sqltypes.DuckDBPyType\n\nCreate a type object by parsing the 'type_str' string\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.union_type", "modulename": "duckdb", "qualname": "union_type", "kind": "function", "doc": "union_type(members: object, *, connection: duckdb.DuckDBPyConnection = None) -> _duckdb._sqltypes.DuckDBPyType\n\nCreate a union type object from 'members'\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.unregister", "modulename": "duckdb", "qualname": "unregister", "kind": "function", "doc": "unregister(view_name: str, *, connection: duckdb.DuckDBPyConnection = None) -> duckdb.DuckDBPyConnection\n\nUnregister the view name\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.unregister_filesystem", "modulename": "duckdb", "qualname": "unregister_filesystem", "kind": "function", "doc": "unregister_filesystem(name: str, *, connection: duckdb.DuckDBPyConnection = None) -> None\n\nUnregister a filesystem\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.values", "modulename": "duckdb", "qualname": "values", "kind": "function", "doc": "values(*args, connection: duckdb.DuckDBPyConnection = None) -> _duckdb.DuckDBPyRelation\n\nCreate a relation object from the passed values\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.view", "modulename": "duckdb", "qualname": "view", "kind": "function", "doc": "view(view_name: str, *, connection: duckdb.DuckDBPyConnection = None) -> _duckdb.DuckDBPyRelation\n\nCreate a relation object for the named view\n", "signature": "(unknown):", "funcdef": "def"}, {"fullname": "duckdb.write_csv", "modulename": "duckdb", "qualname": "write_csv", "kind": "function", "doc": "write_csv(df: pandas.DataFrame, filename: str, *, sep: object = None, na_rep: object = None, header: object = None, quotechar: object = None, escapechar: object = None, date_format: object = None, timestamp_format: object = None, quoting: object = None, encoding: object = None, compression: object = None, overwrite: object = None, per_thread_output: object = None, use_tmp_file: object = None, partition_by: object = None, write_partition_columns: object = None, connection: duckdb.DuckDBPyConnection = None) -> None\n\nWrite the relation object to a CSV file in 'file_name'\n", "signature": "(unknown):", "funcdef": "def"}];

// mirrored in build-search-index.js (part 1)

// Also split on html tags. this is a cheap heuristic, but good enough.

elasticlunr.tokenizer.setSeperator(/[\s\-.;&_'"=,()]+|<[^>]*>/);

let searchIndex;

if (docs._isPrebuiltIndex) {

console.info("using precompiled search index");

searchIndex = elasticlunr.Index.load(docs);

} else {

console.time("building search index");

// mirrored in build-search-index.js (part 2)

searchIndex = elasticlunr(function () {

this.pipeline.remove(elasticlunr.stemmer);

this.pipeline.remove(elasticlunr.stopWordFilter);

this.addField("qualname");

this.addField("fullname");

this.addField("annotation");

this.addField("default_value");

this.addField("signature");

this.addField("bases");

this.addField("doc");

this.setRef("fullname");

});

for (let doc of docs) {

searchIndex.addDoc(doc);

}

console.timeEnd("building search index");

}

return (term) => searchIndex.search(term, {

fields: {

qualname: {boost: 4},

fullname: {boost: 2},

annotation: {boost: 2},

default_value: {boost: 2},

signature: {boost: 2},

bases: {boost: 2},

doc: {boost: 1},

expand: true

});

})();

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

FilesExpand file tree

search.js

Latest commit

History

search.js

File metadata and controls