The Mysql module differs from the distribution standard module in several important ways. Most obviously, it uses FOOP wrappers for MySQL types. It also requires clients to free results instances; in the standard module, only the base MYSQL instance itself must be freed (using MySQL:close-db).

The significance of this is that it is much simpler to create multiple connections (without having to duplicate the entire context at compile time). Result sets are completely independent of each other, and several may be maintained in any state at once. This also means that a spawned process may be given its own Mysql instance to use without having to worry about other processes’ instances interfering. Using the standard module, the entire context would need to be cloned at compile time and given a static symbol reference (e.g., (new 'MySQL 'db)) in order to run multiple instances or connections to a server.

Moreover, because this module uses unpack and MySQL C API accessor functions, there is no need for the client to calculate member offsets in MySQL compound types. So long as newLisp was compiled for the same target as the libmysqlclient library (both are 32 bit or both are 64 bit), everything should work out of the box. Additionally, MySQL errors are now checked in the connect and query functions and re-thrown as interpreter errors. Instead of checking for nil returns and a using MySQL:error to get the error message, standard error  handling with the catch function may be used.

Several convenience functions and macros have been defined in the mysql context for common operations, including connecting to the database and iterating over results without having to worry about catching errors and managing memory. SQL statements may be passed as strings or a list containing a format string and its parameters, which will type-checked and automatically be escaped as needed.

(mysql:on-connect '("localhost" "user" "secret" "my_database")
  (lambda (db err)
    (if err
      (println "Error! " err)
      (mysql:row-iter db "SELECT * FROM some_table" true
        (lambda (row)
          (println row))))))

This module has been tested with MySQL version 5 and 5.1 and newLisp version 10.0.1. It requires newLisp 10.0 or later. You can download it from the Artful Code newLisp module repository.

Submit article

Much of the module uses the small convenience classes to “serialize” SQL expressions. Most of the module’s classes have :serialize methods that render the encapsulated data as a string. For example, the Field class:

(let ((f (Field "table" "fieldname")))
    (:serialize f))
=> "table.fieldname"

…or the Condition class:

(let ((c (Condition ">" "salary" 65000)))
    (:serialize c))
=> "salary > '65000'"

Note that values are enclosed in single quotes for ANSI compliance. The most interesting function in the module, however, is sql:expr, which uses the match-based primitives in the functional module to generate various types of expressions:

(sql:expr "employees" "first_name")
=> "employees.first_name"
 
(sql:expr "LIKE" "first_name" "Stev%")
=> "first_name LIKE 'Stev%'"
 
(sql:expr "OR" (sql:expr "LIKE" "first_name" "Stev%")
               (sql:expr "LIKE" "last_name" "John%"))
=> "((first_name LIKE 'Stev%') OR (last_name LIKE 'John%'))"
 
(sql:expr 6)
=>"6"
 
(sql:expr 'myapp:employees)
=> "employees"
 
(sql:expr "CONV" "AF" 16 10)
=> "CONV('AF',16,10)"
 
(sql:expr "LIKE" (sql:expr "employees" "first_name") "Stev%")
=> "employees.first_name LIKE 'Stev%'"

Additional functions directly express select, update, insert, and delete statements or handle data type conversions (such as parsing SQL datetimes).

Functional

Another addition to Artful Code’s module list is the functional module. This library provides some basic conditionals that make use of match to process data. These macros express program logic by associating blocks of code with the structure of data.

Here is an example using match-case. match-case accepts a single expression and a series of forms that describe what to do based on its structure. Each case form consists of a match expression, a list of variables to be locally bound to the result of the match, and an individual form to evaluate in a local scope with the matched variables bound:

(let ((x '(1 2 3 4 5)))
    (match-case x
        ((? ? ?) (a b c)
         (println "a b and c do not get bound here, because they do not match x"))
        ((? ? ? *) (a b c d)
         (println "a = 1, b = 2, c = 3, and d = '(4 5)"))))

Here, the second block would match because (? ? ? *) matches against (1 2 3 4 5) and creates the binding association, ((a 1) (b 2) (c 3) (d (4 5))).

Also included in the module is match-cond, which is more powerful than match-case. match-cond works like cond, except that instead of a user-defined conditional, the first form in each case is a list of pattern, symbol-list, and target. See the documentation for more details.

Edit (2009-02-16): the functional module in mentioned in this post has been replaced with the matching module.

Submit article

To be fair, the FOOP operator, :, does not provide any truly new functionality to newLISP. However, it does make prototyping much more concise and expressive.

The basics

Prototyping is accomplished using a source context (a lexical closure) and the new keyword. Using the commonly contrived example of the Rectangle object:

(context 'Rectangle)
(set 'x nil)
(set 'y nil)
(define (area) (* x y))
 
(context MAIN)
(new Rectangle 'my-rectangle)
(set 'my-rectangle:x 10)
(set 'my-rectangle:y 20)

FOOP uses the convention of (object member member ...) for storing object instances. Instance data, apart from the members, is encapsulated within the context, so all of the methods may access contextually set variables. Although not built into the interpreter, the functional convention,

(define (Class:Class) (cons (context) (args)))

…is typically used to create new contexts for FOOP. Using Class, the above example would be written as:

(new Class 'Rectangle)
(set 'my-rectangle (Rectangle 10 20))

Methods are attached via the normal syntax for declaring foreign context functions, but with the assumption of the argument being the (object member member ...) convention and implicit indexing:

(define (Rectangle:area self)
    (* (self 1) (self 2)))

All of the normal operations that apply to contexts remain applicable for contexts created in this fashion. One interesting element of FOOP is that the methods and namespace are separate from the object’s properties. Therefore, an arbitrary list of values can be consed by a cloned context to create a new instance.

Constructors are easily overridden using default functors. In fact, Class:Class merely automates the creation of a default functor for a new context.

So, if we wanted a Rectangle with default x and y values:

(define (Rectangle:Rectangle (x 10) (y 10))
    (list (context) x y))

Solving problems with FOOP

Although FOOP would not be considered a true object oriented system by purists (who would call it prototyping), it is an excellent substitute for a true type system. For example, here is a simple interface for probing and validating command-line arguments:

;; In case Class is not yet defined, attempt to define
(catch
  (define (Class:Class)
    (cons (context) (args))))
 
;; Declare our classes
(new Class 'Option)
(new Class 'Switch) ; Option's identifying token
(new Class 'Required) ; Defines option as required
(new Class 'Predicate) ; Lambda to validate and option's value
 
;; Define a method to find this option in (main-args)
(define (Option:get self , loc val)
  (set 'switch (last (assoc (self Switch))))
  (if (set 'loc (find switch (main-args)))
    (cond
      ((and (starts-with switch "--")
            (catch (nth (+ 1 loc) (main-args)) 'val))
        val)
      ((starts-with switch "--") true)
      ((starts-with switch "-") true)
      (true nil))
    nil))
 
;; Define a predicate to validate the value of our option.
;; In case the option does not come with a value, we skip the predicate
;; part and validate solely based on the value of Required.
(define (Option:valid? self , val req pred req? pred?)
  (set 'val (:get self))
  (set 'req? (assoc (self Required)))
  (set 'pred? (assoc (self Predicate)))
  (set 'req (if req? (true? val) true))
  (set 'pred (if pred? ((last pred?) val) true))
  (and req pred))

The Option class is made up of several other classes, Switch, Required, and Predicate. Switch is the token to identify the option in the command-line arguments. Switches that begin with — can take an optional value, such as --url http://www.artfulcode.net. Required is another empty class that only needs to be a boolean value. Predicate optionally stores a lambda that will be used to validate the value found in (main-args).

Here is a sample of how we might use Option:

(set 'url (Option
    (Switch "--url")
    (Required true)
    (Predicate
        (lambda (val) (true? (regex {^http://.*?$} val 17))))))

For a single on/off switch, we can do:

(set 'some-option (Option
    (Switch "-s")
    (Required nil)))

To get the values and validate them:

artful:~ newlisp test.lsp --url http://www.artfulcode.net -s
 
(url:get) ; => "http://www.artfulcode.net"
(some-option:get) ; => true
 
(url:valid?) ; => true
(some-option:valid?) ; => true

And for non-validating values:

artful:~ newlisp test.lsp --url "Hello world"
 
(url:get) ; => "Hello world"
(url:valid?) ; => nil

newLISP 9.3′s new association list processing functions make accessing member cells a snap – (assoc (object key)). Obviously, this is more expressive and concise than a lot of recursive parsing of (main-args). The trade-off is the same as with any use of OOP: contexts are more expensive than list processing, especially when creating many small context instances.

This is obviously a contrived example and could be solved more efficiently quite easily, but it does a good job of illustrating FOOP.

What makes it functional?

That’s tough to quantify. However, if we want to shorten the class declarations in the code above to simplify our code, we could use use the higher order functions map and curry:

(map (curry new Class) '(Option Switch Required Predicate))

Other examples might be to compose custom classes as needed using macros, updating a list of class instances using map, or currying class constructors to extend classes.

What next?

There are better and more extensive tutorials available in video form courtesy of Michael Michaels of neglOOk available on the newLisp website.

download

Submit article