A Deep Dive into PL/v8
Back in August, Compose.io announced the addition of JavaScript as an internal language for all new PostgreSQL deployments. This was thanks to the PL/v8 project, which straps Google's rocket of a JavaScript engine (V8) to PostgreSQL. This got me thinking - PL/v8 offers a rich and featureful way to write functions in PostgreSQL. Let's take a look at what it offers by building a mini JavaScript module system on top of it, complete with basic support for the CommonJS API.
Enabling PL/v8 on Your Deployment
First thing's first: you'll need to enable it by creating the extension. The quickest and easiest way to do this is likely using psql from a terminal (below), but if you prefer using another tool it shouldn't pose any problems.
# You can find your login details over on your deployment's overview page
psql "sslmode=require host=[host] port=[port] dbname=[dbname] user=[username]"
-- Once you've logged in, execute the statement below to enable plv8
create extension plv8;
PL/v8 also supports two extra JavaScript "dialects" - CoffeeScript, and LiveScript. CoffeeScript offers a more Ruby-esque syntax, and LiveScript is a more functional successor to CoffeeScript. We'll be using pure JavaScript in this article, but if you'd like to use either of these languages you'll need to create their extensions below as well.
-- If you prefer a different JS dialect, both CoffeeScript and LiveScript
-- are supported. Create their extensions to use them!
create extension plcoffee;
create extension plls;
JavaScript in PostgreSQL: The Basics
Creating a function using PL/v8 looks like any other PostgreSQL function, with the exception of a language specifier change. Take the (basic) example below: we're simply incrementing each int in an Array by 2, and returning it as pure JSON.
create or replace function addtwo(vals int[])
returns json as $$
return vals.map(function(i) {
return i + 2;
});
$$ language plv8;
select addtwo(array[0, 47, 30]);
-- Returns [2, 49, 32]
JavaScript isn't technically a functional programming language, but it has many elements of one. Those features shine here - mapping over results is incredibly expressive and easy to work with. While you can't get all crazy with any ES6 code yet (the version of V8 currently used is a bit older), pretty much all the good parts of ES5 are up for grabs. Couple that with the native JSON support PostgreSQL offers, and you can get many of the features (e.g, Schema-less storage) from Document-oriented databases like MongoDB or RethinkDB.
As far as working with SQL data in JavaScript goes, it's relatively straightforward. PL/v8 will convert most database types automatically for you, including polymorphic types (anyelement
, anyarray
, anyenum
and anynonarray
) and bytea
(through JavaScript's Typed Arrays). The only real "gotchas" to be aware of are that any Array you return must be flattened (unless you're returning JSON, in which case go for it), and you can't create your own Typed Arrays for use in functions; you can, however, modify and return the ones passed to your function.
While not strictly a "gotcha", the ever-so-fun issue of context in JavaScript is present in PL/v8. Each SQL function is called with a different_this_ value, and it can be confusing at first. SQL functions do share context though, as far as accessing globally declared variables and functions. As long as you pay attention to scoping issues, you can avoid context binding issues and write reusable code.
Hacking Together a Module System
V8 is synonymous with Node.js for many developers, and inevitably the question of importing modules comes up. There is no baked-in module system, but we can simulate one using some of the features of PL/v8. It's important to note that while this works, we're in a sandboxed environment - modules involving network calls or browser-related functionality won't work. We'll be simulating the CommonJS module.exports
API though, so many modules should "just work" right off npm.
The first thing we'll need is a table to store our module source(s) in. We really only need two columns to start: the module name (module
), and the source code (source
). To sweeten the deal we'll add an autoload column (autoload
) that we'll use to dictate whether a module should be transparently available at all times.
create table plv8_js_modules (
module text unique primary key,
autoload bool default true,
source text
);
We'll need a function to handle wrapping the require()
API, and ideally we'll want a cache for module loading so we're not pulling from a database table every time we require a module. The global plv8
object has a few things we'll make use of here - it brings important functionality like executing statements, subtransactions, logging and more to the table. We'll be eval()
ing the source for each module, but we wrap it in a function to ensure nothing leaks into the global scope. Our autoloading of certain modules also takes place in this function, just to prime the module cache for later use.
create or replace function plv8_require()
returns void as $$
moduleCache = {};
load = function(key, source) {
var module = {exports: {}};
eval("(function(module, exports) {" + source + "; })")(module, module.exports);
// store in cache
moduleCache[key] = module.exports;
return module.exports;
};
require = function(module) {
if(moduleCache[module])
return moduleCache[module];
var rows = plv8.execute(
"select source from plv8_js_modules where module = $1",
[module]
);
if(rows.length === 0) {
plv8.elog(NOTICE, 'Could not load module: ' + module);
return null;
}
return load(module, rows[0].source);
};
// Grab modules worth auto-loading at context start and let them cache
var query = 'select module, source from plv8_js_modules where autoload = true';
plv8.execute(query).forEach(function(row) {
load(row.module, row.source);
});
$$ language plv8;
Now in terms of using this, we have that dangling context problem to consider - how do we make sure that require()
is available to each PL/v8 function that needs it? Well, it just so happens that PL/v8 supports setting a specific function to run before any other functions run. We can use this hook to bootstrap our environment - while ordinarily you could set it in your config files, you don't have access to those on Compose. We can, however, SET
this value every time we open a connection. As long as you do this prior to any function call (including CREATE FUNCTION
itself) you'll have access to require()
.
-- PL/v8 supports a "start proc" variable that can act as a bootstrap
-- function. Note the lack of quotes!
SET plv8.start_proc = plv8_require;
Let's try it out by throwing together a module that implements the Fisher-Yates shuffle algorithm - we'll name the module "shuffle", to keep things simple, and go ahead and set it to autoload.
insert into plv8_js_modules (module, autoload, source) values ('shuffle', true, '
module.exports = function(arr) {
var length = arr.length,
shuffled = Array(length);
for(var i = 0, rand; i < length; i++) {
rand = Math.floor(Math.random() * (i + 1));
if(rand !== i)
shuffled[i] = shuffled[rand];
shuffled[rand] = arr[i];
}
return shuffled;
};
');
Now we should be able to require()
this! We can try it immediately - a simple table of people and a super readable random_person()
function works well.
create table people (
id serial,
name varchar(255),
age int
);
insert into people (name, age) values
('Ryan', 27),
('Daniel', 25),
('Andrew', 23),
('Sam', 22);
create or replace function random_person()
returns json as $$
var shuffle = require('shuffle'),
people = plv8.execute('select id, name, age from people');
return shuffle(people);
$$ language plv8;
select random_person();
-- Example Response:
-- [{
-- "id": 3,
-- "name": "Andrew",
-- "age": 23
-- }, {
-- "id": 1,
-- "name": "Ryan",
-- "age":27
-- }, {
-- "id": 4,
-- "name": "Sam",
-- "age": 22
-- }, {
-- "id": 2,
-- "name": "Daniel",
-- "age": 25
-- }]
See how clean that becomes? A shuffle algorithm is only one application - modules like lodash are a prime candidate to check out for using here.
What Are You Waiting For?
Writing PostgreSQL functions in JavaScript can provide a few wins - if your stack is primarily JavaScript, there's less context-switching involved when dealing with your database. You can reap the benefits of Document-oriented, Schema-less databases while leaving yourself the option to get relational as necessary, and the native support for JSON marries perfectly with JavaScript. Modules can tie it all together and provide a method for organizing code that makes sense - you'll feel right at home.
Even more in-depth documentation on PL/v8 can be found over on the official docs. Try it out today!
A Deep Dive into PL/v8的更多相关文章
- X64 Deep Dive
zhuan http://www.codemachine.com/article_x64deepdive.html X64 Deep Dive This tutorial discusses some ...
- Deep Dive into Spark SQL’s Catalyst Optimizer(中英双语)
文章标题 Deep Dive into Spark SQL’s Catalyst Optimizer 作者介绍 Michael Armbrust, Yin Huai, Cheng Liang, Rey ...
- Generating YouTube-like IDs in Postgres using PL/V8 and Hashids
转自:https://blog.abevoelker.com/2017-01-03/generating-youtube-like-ids-in-postgres-using-plv8-and-has ...
- 《Docker Deep Dive》Note - Docker 引擎
<Docker Deep Dive>Note Docker 引擎 1. 概览 graph TB A(Docker client) --- B(daemon) subgraph Docker ...
- 《Docker Deep Dive》Note - 纵观 Docker
<Docker Deep Dive>Note 由于GFW的隔离,国内拉取镜像会报TLS handshake timeout的错误:需要配置 registry-mirrors 为国内源解决这 ...
- Deep Dive into Neo4j 3.5 Full Text Search
In this blog we will go over the Full Text Search capabilities available in the latest major release ...
- 重磅解读:K8s Cluster Autoscaler模块及对应华为云插件Deep Dive
摘要:本文将解密K8s Cluster Autoscaler模块的架构和代码的Deep Dive,及K8s Cluster Autoscaler 华为云插件. 背景信息 基于业务团队(Cloud BU ...
- vue3 deep dive
vue3 deep dive vue core vnode vue core render / mount / patch refs https://www.vuemastery.com/course ...
- A Deep Dive Into Draggable and DragTarget in Flutter
https://medium.com/flutter-community/a-deep-dive-into-draggable-and-dragtarget-in-flutter-487919f6f1 ...
随机推荐
- nginx学习笔记2
nginx基础配置 一.nginx常用命令 nginx -s reload:在nginx已经启动的情况下重新加载配置文件(平滑重启) nginx -s reopen:重新打开日志文件 nginx -c ...
- express常见获取参数的方法
1.req.query 处理get请求 // GET /search?q=tobi+ferret req.query.q // => "tobi ferret" // GET ...
- centos7上配置mysql8的主从复制
注意:1.主库:10.1.131.75,从库:10.1.131.762.server-id必须是纯数字,并且主从两个server-id在局域网内要唯一. [主节点]vi /etc/my.cnf[mys ...
- Django-查询优化
表数据: from django.db import models class Province(models.Model): name = models.CharField(max_length=1 ...
- jenkins+sonarqube进行代码质量检测
JavaNeverGiveUp教程篇 用jenkins+sonarqube去检查代码是非常方便的,它能检查出代码中可能存在的一些问题,比如io流未关闭.空指针异常.死循环.代码不规范等问题. 1. 搭 ...
- AWS云创建EC2与使用注意事项-踩坑记录
目录 AWS 一 创建 EC2(云服务器) 二.AWS 注意事项 三.AWS 申请 SSL 证书 四. 创建VPC AWS 文章 GitHub 地址: 点我 AWS云服务器价格计算器 AWS WEB ...
- Barrier 组织多个线程及时在某个时刻碰面
任意一个线程调用了 _barrier.SignalAndWait() 方法后,会执行一个回调函数来打印出阶段. /// <summary> /// 实例 Barrier 类 /// < ...
- java DES转C#DES加密解密
一个程序用到java的cn.core.jar加密的,需要在.NET 中解密,发现JAVA的des算法与C#的有点区别. 自己不太懂加密解密算法,所以找了个省事的方法,用IKVM.NET,用这个将cn. ...
- ElasticSearch 查询索引
GET iis_qr_2019-07/_search #查询iis_qr_2019-07索引下的所有日志 GET iis_qr_2019-07/_search?_source=c-ip,time #只 ...
- 如何开发出成功的iOS应用(流程图)
转自:http://mobile.51cto.com/hot-307342.htm 近来,肥沃的应用开发土壤不断孕育出一个个振奋人心的故事,成千上万的人都觊觎从这个机遇无限的领域中分一杯羹.虽然现在的 ...