LISP How to create a database storing function parameters

For experimental and quick projects, I tend to use a simple text file that just stores the s-expression.

A very simple database:

(format open-file-stream "~S" any-sexp)

You can look up an entry using some simple functions.

To look up by (implicit) index:

(defun read-nth-sexp (n file)
  (with-open-file 
    (file-stream file) 
    (loop for i from 0 
      for sexp = (read file-stream nil)
      do (if (eq n i) (return sexp)))))

To find by key: (Note: You store the key by just adding it to the sexp anywhere in the structure of the sexp, when you stored it. Later you can get at it by providing the relevant selector function, by default assumed to be #'car.)

(defun find-entry (entry file &key (select #'car))
  (with-open-file 
    (file-stream file) 
    (loop for sexp = (read file-stream nil)
      while sexp
      do (if (equal (funcall select sexp) entry)
             (return sexp)))))

This works well for upto 10,000's or maybe 100'000s of entries, depending on your hardware. I've had difficulty dealing with anything above half million entries.

I haven't had the need to update my data, and so I never wrote any updation functions but they can be written easily.

For very fast search, I've had success with binary search assuming of course your data has sortable properties.

You could design a database in Lisp vs. using a persistent storage database, and you could save the data in a serialized format in order to load/save the database. You'd be surprised, but some big companies such as Yahoo! did this in the 90's, and many still do it today, vs. using a persistent database such as MySQL. Here is an example of the structure of the program if you want to write the database in Lisp. You could use the CLOS to store functions as instances of that class. You say that you need the function name, and the function parameters. So you could create a class with the attributes "name" and "parameters". Here is an example:

 (defclass functions()
   ((name :accessor func-name
      :initarg :name)
    (params :accessor func-params
        :initarg :params
        :initform '(nil))))

We can create a class with slots for the name and parameters as I showed above, and then we can create instances of that class. So if for example I have a function like this:

(defun foo (n lst)
    (list foo))

I can should create an instance like this...

 (defvar func-1 (make-instance 'functions
                   :name "foo"
                   :params '("n" "lst")))

And if I have a function like this:

(defun foo-2(lst n)
    (list lst n))

I can create another instance like this:

(defvar func-2 (make-instance 'functions
                   :name "foo-2"
                   :params '("lst" "n")))

Now how do we store these instances in a database? We have a few options, but a simple and general example would be to store the instances in a list. We could increase the complexity, or even create our own form of an embedded SQL language using Macros, but to keep it simple, we can just use a list and the find function in order to create a make-shift database. Here is an example of a database and two functions to search that database based on a functions name or parameters:

(defvar *func-db* nil) ;Create an empty list to store the functions
(push func-1 *func-db*)
(push func-2 *func-db*) ;Push a couple of functions to the DB

(defun find-params (name)
   (func-params
    (find name *func-db*
      :test #'string-equal
      :key #'func-name)))

(defun find-name (param-list)
   (func-name 
    (find param-list *func-db*
      :test #'equal
      :key #'func-params))

Now we can create a couple of functions to find the params of a function based on the name we search, or find the name of a function based on the params we enter. I will use Strings in this scenario for a simple illustration, but you should probably use symbols. Here are a couple of examples of how we would search the DB:

CL-USER> (find-params "foo")
("n" "lst")
CL-USER> (find-params "foo-2")
("lst" "n")
CL-USER> (find-name '("n" "lst"))
"foo"
CL-USER> (find-name '("lst" "n"))
"foo-2"

That is how we can make a make-shift database in Lisp. A good book to read would be "Practical Common Lisp". There's a free online version, and in that book, one of the main projects is creating an MP3 database. The most simple example is using a List to store information and then searching it. If you want to save the database for later usage, you can save it to a file, and then load it when you want to use it again. This technique might seem simple, but I've seen big companies use it vs. MySQL. You can even create your own embedded SQL language to search for the information, and since the information is stored in memory it could retrieve results even faster than MySQL if you decided to extend this project and create a web application in Lisp.