SQLite with Gliimly

This example will create a service that inserts key and value into SQLite table. It's tested from command line.

Create a directory and then switch to it:

mkdir sqlite
cd sqlite

Copied!

Setup SQLite database in file "mydata.db":

echo 'drop table if exists key_value; 
create table if not exists key_value (key varchar(50) primary key, value varchar(100));' | sqlite3 mydata.db

Copied!

Create configuration file "mydb" that describes the SQLite database "mydata.db":

echo "$(pwd)/mydata.db"> mydb

Copied!

Create the application:

sudo mgrg -i -u $(whoami) sqlite

Copied!

Create file insert.gliim:

vim insert.gliim

Copied!

Copy and paste to it (note use of database configuration "mydb" in @mydb):

 %% /insert public
     get-param key
     get-param value
     run-query @mydb = "insert into key_value(key,value) values ('%s', '%s')" input key, value error err affected-rows aff_rows no-loop
     @Error <<p-out err>>, affected rows <<p-num aff_rows>>
 %%

Copied!

Compile the application - we specify that file "mydb" is describing SQLite database:

gg -q --db=sqlite:mydb

Copied!

Run the application by executing this service from command line. Note passing the input parameters "key" and "value" to it:

gg -r --req="/insert/key=1/value=one" --exec --silent-header

Copied!

The output is:

Error 0, affected rows 1

Copied!

Verify data inserted:

echo -e ".headers off\n.mode line\nselect key "Key", value "Value" from key_value"|sqlite3 mydata.db

Copied!

The result:

Key = 1
Value = one

Copied!

Copy-code icon added

Copy icon () is now in the upper right corner of all code blocks in Gliimly documentation, as well as this blog.

Click this icon to copy the code. This is useful for getting the sample code in your own, learning Gliimly etc.

Gliimly 44 released

Bug fixes:

• Fixed bug where a memory for parameters or split-string type could be allocated with no data causing invalid write in debug mode only. 
• Fixed bug where passing a number from sub-request back to the caller would not be correct or could cause invalid memory read.
• Fixed bug in encryption statement (encrypt-data) with checking memory bounds of Initialization Vector (IV).
• Fixed bug in executing SQL with any database. The bug was with checking the formatting of the statement.

New features and improvements:

• Added -z command-line option to Service Manager (mgrg). This option suppresses HTTP header  for all service requests in application (equivalent to implicit silent-header statement at the beginning of each request handler).
• Improved performance of piping output from execution of programs in exec-program statement.
• Improved performance of message composition in write-message statement.
• Structured types can now be returned to caller from sub-handler - for instance creating a new index or array.

Overview of Gliimly

Gliimly is a new programming language and framework for developing web services and web applications. The reason for Gliimly is to make software development easier, more reliable and to improve run-time performance. To do this, Gliimly is a very high level language yet it's a high performance one; those two qualities aren't usually together.

Gliimly is a declarative language designed for simplicity. That means top-down approach, rather than bottom-up: it's more about describing what to do than coding it. It's a modeling language where pieces are assembled together quickly and with confidence. It's about the framework to create and deploy web services with less effort and faster.

Gliimly is a memory-safe language. Your program is safe from overwriting memory it shouldn't overwrite, and it won't leave dangling pointers hanging around. Gliimly is a static-typed language with only three basic types (strings, numbers and boolean) and (currently) the following structured types: service, message, array, index, index-cursor, fifo, lifo, list, split-string and file.

Gliimly 37 released

• Added "new-line" clause to output statements, such as p-out, p-web, p-url, p-path and p-num. This clause adds new line to the output of any of these statements.
• Fixed bug in write-string where program errors out in some cases with multiple use of encoded output statements, such as p-web for instance.

Web service Hello World

To access a Gliim service on the web, you need to have a web server or load balancer (think Apache, Nginx, HAProxy etc.).

This assumes you have completed the Hello World as a Service, with a service built and tested via command line.

In this example, Nginx web server is used; edit its configuration file. For Ubuntu and similar:

sudo vi /etc/nginx/sites-enabled/default

Copied!

while on Fedora and other systems it might be:

sudo vi /etc/nginx/nginx.conf

Copied!

Add the following in the "server {}" section:

location /hello/ { include /etc/nginx/fastcgi_params; fastcgi_pass  unix:///var/lib/gg/hello/sock/sock; }

Copied!

"hello" refers to your Hello World application. Finally, restart Nginx:

sudo systemctl restart nginx

Copied!

Now you can call your web service, from the web. In this case it's probably a local server (127.0.0.1) if you're doing this on your own computer. The URL would be:

http://127.0.0.1/hello/hello-world/name=Mike

Copied!

Note the URL request structure: first comes the application path ("/hello") followed by request path ("/hello-world") followed by URL parameters ("/name=Mike"). The result:

Hello World as a Service

Writing a service is the same as writing a command-line program in Gliim. Both take the same input and produce the same output, so you can test with either one to begin with.

For that reason, create first Hello World as a command-line program.

The only thing to do afterwards is to start up Hello World as application server:

mgrg hello

Copied!

Now there's a number of resident processes running, expecting clients requests. You can see those processes:

ps -ef|grep hello

Copied!

The result:

bear       25772    2311  0 13:04 ?        00:00:00 mgrg hello
bear       25773   25772  0 13:04 ?        00:00:00 /var/lib/gg/bld/hello/hello.srvc
bear       25774   25772  0 13:04 ?        00:00:00 /var/lib/gg/bld/hello/hello.srvc
bear       25775   25772  0 13:04 ?        00:00:00 /var/lib/gg/bld/hello/hello.srvc
bear       25776   25772  0 13:04 ?        00:00:00 /var/lib/gg/bld/hello/hello.srvc
bear       25777   25772  0 13:04 ?        00:00:00 /var/lib/gg/bld/hello/hello.srvc

Copied!

"mgrg hello" runs the Gliim process manager for application "hello". A number of ".../hello.srvc" processes are server processes that will handle service request sent to application "hello".

Now, to test your service, you can send a request to the server from command line (by using "--service" option):

gg -r --req="/hello-world/name=Mike" --exec --silent-header --service

Copied!

The above will make a request to one of the processes above, which will then reply:

This is Hello World from Mike

Copied!

Gliimly 32 released

• HTTP header is now sent to client by default at the very first output, i.e. the equivalent of 'out-header default' statement.No code change is necessary. Typical use of out-header is to send default headers at the very beginning of a service, and those can in general be removed now, since it's done automatically.
  
  
• Color scheme is now supported for Gliimly source code. Prior to this release, there was one hardcoded colorscheme. Now your can use any available color  scheme to customize look and feel of source code in Vim editor (use ":colorscheme" command).

Using Vim color schemes with Gliimly

Gliimly installation comes with a Vim module for highlighting Gliimly code. After installing Gliimly, run this to install the Vim module:

gg -m

The default color scheme looks like this:

To change color scheme, type ":colorscheme " in command mode, then press Tab to see available color schemes. Press Enter to choose one. For instance, in 'darkblue' color scheme, it may look like:

To make the change permanent, edit file ".vimrc" in home directory:

vi ~/.vimrc

and append line:

colorscheme darkblue

Hello World in Gliimly

Create a directory for your Hello World application and then switch to it:

mkdir hello-world
cd hello-world

Copied!

Create the application:

sudo mgrg -i -u $(whoami) hello

Copied!

Create a file hello-world.gliim:

vim hello-world.gliim

Copied!

and copy this code to it:

 begin-handler /hello-world public
     get-param name
     @This is Hello World from <<p-out name>>
 end-handler

Copied!

This service takes input parameter "name" (see get-param), and then outputs it along with a greeting message (see output-statement).

Compile the application:

gg -q

Copied!

Run the application by executing this service from command line. Note passing the input parameter "name" with value "Mike":

gg -r --req="/hello-world/name=Mike" --exec --silent-header

Copied!

The output is:

This is Hello World from Mike

Copied!

Gliimly is at https://gliimly.github.io/.

Introduction to Gliimly

Gliimly is a new programming language and framework for developing web services and web applications. It is:

• declarative language designed for simplicity,
  
• memory-safe,
  
• functional statically-typed,
  
• high-performance compiled language, designed to create fast and small native executables without interpreters or p-code,
  
• built on top of industry-standard Open Source libraries, such as SSL, Curl, MariaDB and others, in addition to native Gliimly's,
  
• extensible with any standard libraries,
  
• very simple to work with by design to reduce comlexity and improve performance.

Initial Gliimly release

Version 25 is an initial Gliimly release.

The official web site is at gliimly.github.io. It is also accessible (for now, but not indefinitely) from vely.dev since Gliim evolved from Vely. Gliimly and Vely are copyright (c) Gliim LLC licensed under their respective licenses and developed by the same team.

Git source code repository is at github.com/gliimly/gliimly.

Gliimly is licensed under Apache 2 Free Open Source license.