I just did another little article.

https://www.vajhoej.dk/arne/articles/vmsdbx.html

providing some examples for the databases available on VMS (Rdb, MySQL,
SQLite, Mimer, Derby, H2, HSQLDB) in various programming languages
(Cobol, C, Pascal, Java, Jython, Python, PHP).

Nothing surprising and a lot of overlap with previous
articles, but a different perspective.

Arne

On 11/17/2023 8:10 PM, Arne Vajhøj wrote:
> I just did another little article.
>
> https://www.vajhoej.dk/arne/articles/vmsdbx.html
>
> providing some examples for the databases available on VMS (Rdb, MySQL,
> SQLite, Mimer, Derby, H2, HSQLDB) in various programming languages
> (Cobol, C, Pascal, Java, Jython, Python, PHP).
>
> Nothing surprising and a lot of overlap with previous
> articles, but a different perspective.

Niel Rieck replied (for some reason the post did not propagate
to eternal-september, so this is a manual copy from Google Groups):

> Two additional points.
>
> 1) I've done a bit of hacking with SQLite (on both OpenVMS + Linux )
> and can inform that it should only be used in single user
> applications. When any process issues an "update table" command, all
> other processes are locked out.

For multi user scenarios database servers are usually better than
embedded databases.

I would have thougth SQLite could only have locked some part of
the database when doing an UPDATE, but ...

> 2) Back in 2016 I received a copy of MariaDB-5.5 for OpenVMS Itanium
> from Mark Berryman. Since 90% of our VMS stuff is written in BASIC, I
> spent more than a few days trying to glue Mark's client code to my
> BASIC programs (we are in the process of moving our data from RMS to
> MariaDB). Linking the object files was fairly easy using Mark's
> instructions. Trying to pass string arrays from C to BASIC was a
> little more difficult. My eventual solution involved created string
> arrays in a BASIC declared COMMON then had C employ str$get1_dx() to
> copy the data back. I would be interested to learn if you had a better
> method.

> https://neilrieck.net/demo_vms_html/mysql_api_demo14_c.html
> (crude c demo)
> https://neilrieck.net/demo_vms_html/mysql_demo14_bas.html
> (crude BASIC demo)

VMS Basic is as it is and the libmysql API is what it is and
any solution is constrained by that.

I do not have any magic solution for the problem. I would
probably have made the API differently (but differently does
not necessarily mean better).

Arne

On 11/18/2023 8:22 AM, Arne Vajhøj wrote:
> Niel Rieck replied (for some reason the post did not propagate
> to eternal-september, so this is a manual copy from Google Groups):

Ray has had to disconnect GG for a day or two at a time while he deals
with fine tuning Spam Assassin. Some of the worst hit groups are getting
over 5000 spam messages a day, the greatest majority of them from GG.

In fact, the majority of them may be coming from one spammer on GG. I
haven't gone to look but I understand he's currently taunting Ray on
es.support.

On Saturday, November 18, 2023 at 10:05:47 AM UTC-5, Jay E. Morris wrote:
> On 11/18/2023 8:22 AM, Arne Vajhøj wrote:
> > Niel Rieck replied (for some reason the post did not propagate
> > to eternal-september, so this is a manual copy from Google Groups):
> Ray has had to disconnect GG for a day or two at a time while he deals
> with fine tuning Spam Assassin. Some of the worst hit groups are getting
> over 5000 spam messages a day, the greatest majority of them from GG.
>
> In fact, the majority of them may be coming from one spammer on GG. I
> haven't gone to look but I understand he's currently taunting Ray on
> es.support.

Curious. I woke up today with an idea to check two others groups that I'm a member of.

These groups appear to be clear of the spam seen in comp.os.cov which means that the spamers are being selective.

https://groups.google.com/g/bluegriffon
https://groups.google.com/g/alt.fan.blade-runner

Neil Rieck
Waterloo, Ontario, Canada.
https://neilrieck.net/OpenVMS-Programmers-Corner.html

On Saturday, November 18, 2023 at 11:21:22 AM UTC-5, Neil Rieck wrote:
> On Saturday, November 18, 2023 at 10:05:47 AM UTC-5, Jay E. Morris wrote:
> > On 11/18/2023 8:22 AM, Arne Vajhøj wrote:
> > > Niel Rieck replied (for some reason the post did not propagate
> > > to eternal-september, so this is a manual copy from Google Groups):
> > Ray has had to disconnect GG for a day or two at a time while he deals
> > with fine tuning Spam Assassin. Some of the worst hit groups are getting
> > over 5000 spam messages a day, the greatest majority of them from GG.
> >
> > In fact, the majority of them may be coming from one spammer on GG. I
> > haven't gone to look but I understand he's currently taunting Ray on
> > es.support.
> Curious. I woke up today with an idea to check two others groups that I'm a member of.
>
> These groups appear to be clear of the spam seen in comp.os.cov which means that the spamers are being selective.
>
> https://groups.google.com/g/bluegriffon
> https://groups.google.com/g/alt.fan.blade-runner
> Neil Rieck
> Waterloo, Ontario, Canada.
> https://neilrieck.net/OpenVMS-Programmers-Corner.html

RE: SPAM

FYI, every time I visit https://groups.google.com/g/comp.os.vms/ I make it my duty to mark at least 120 pieces of SPAM.

This is easier then you might think. You just click the square box at the top of the page (which selects 30 items), then do a quick scan of items you wish to deselect (they are few), then click the blue circle containing an exclamation. A popup menu will appear, select an item, then click "submit report". Bang. 30 items now flagged.

Not sure if google is running any A.I. to make sense of all this, but Google is now presenting an "I am not a robot" dialog for any submission or reply to cov

Perhaps google will take more action if others repeat what I am doing.

Neil Rieck
Waterloo, Ontario, Canada.
https://neilrieck.net

In article <ujajs7$3bls0$1@epsilon3.eternal-september.org>,
Jay E. Morris <morrisj@epsilon3.comcon> wrote:
>On 11/18/2023 8:22 AM, Arne Vajhøj wrote:
>> Niel Rieck replied (for some reason the post did not propagate
>> to eternal-september, so this is a manual copy from Google Groups):
>
>Ray has had to disconnect GG for a day or two at a time while he deals
>with fine tuning Spam Assassin. Some of the worst hit groups are getting
>over 5000 spam messages a day, the greatest majority of them from GG.

All of them from GG. In fact, I would probably not be out of line to say
that all Usenet spam in the past decade has been from GG. All of it.
--scott
--
"C'est un Nagra. C'est suisse, et tres, tres precis."

On Friday, November 17, 2023 at 8:10:25 PM UTC-5, Arne Vajhøj wrote:
> I just did another little article.
>
> https://www.vajhoej.dk/arne/articles/vmsdbx.html
>
> providing some examples for the databases available on VMS (Rdb, MySQL,
> SQLite, Mimer, Derby, H2, HSQLDB) in various programming languages
> (Cobol, C, Pascal, Java, Jython, Python, PHP).
>
> Nothing surprising and a lot of overlap with previous
> articles, but a different perspective.
>
> Arne
Python can use the pysqlite module to interface to SQLite using Python's
DB API. This API supports several other databases as well.

On Saturday, November 18, 2023 at 11:42:03 AM UTC-5, Neil Rieck wrote:
> On Saturday, November 18, 2023 at 11:21:22 AM UTC-5, Neil Rieck wrote:
> > On Saturday, November 18, 2023 at 10:05:47 AM UTC-5, Jay E. Morris wrote:
> > > On 11/18/2023 8:22 AM, Arne Vajhøj wrote:
> > > > Niel Rieck replied (for some reason the post did not propagate
> > > > to eternal-september, so this is a manual copy from Google Groups):
> > > Ray has had to disconnect GG for a day or two at a time while he deals
> > > with fine tuning Spam Assassin. Some of the worst hit groups are getting
> > > over 5000 spam messages a day, the greatest majority of them from GG.
> > >
> > > In fact, the majority of them may be coming from one spammer on GG. I
> > > haven't gone to look but I understand he's currently taunting Ray on
> > > es.support.
> > Curious. I woke up today with an idea to check two others groups that I'm a member of.
> >
> > These groups appear to be clear of the spam seen in comp.os.cov which means that the spamers are being selective.
> >
> > https://groups.google.com/g/bluegriffon
> > https://groups.google.com/g/alt.fan.blade-runner
> > Neil Rieck
> > Waterloo, Ontario, Canada.
> > https://neilrieck.net/OpenVMS-Programmers-Corner.html" rel="nofollow" target="_blank">https://neilrieck.net/OpenVMS-Programmers-Corner.html
> RE: SPAM
>
> FYI, every time I visit https://groups.google.com/g/comp.os.vms/ I make it my duty to mark at least 120 pieces of SPAM.
>
> This is easier then you might think. You just click the square box at the top of the page (which selects 30 items), then do a quick scan of items you wish to deselect (they are few), then click the blue circle containing an exclamation. A popup menu will appear, select an item, then click "submit report". Bang. 30 items now flagged.
>
> Not sure if google is running any A.I. to make sense of all this, but Google is now presenting an "I am not a robot" dialog for any submission or reply to cov
>
> Perhaps google will take more action if others repeat what I am doing.
> Neil Rieck
> Waterloo, Ontario, Canada.
> https://neilrieck.net
I do the same.

On Saturday, November 18, 2023 at 11:42:03 AM UTC-5, Neil Rieck wrote:

> Not sure if google is running any A.I. to make sense of all this, but Google is now presenting an "I am not a robot" dialog for any submission or reply to cov
>
> Perhaps google will take more action if others repeat what I am doing.
> Neil Rieck
> Waterloo, Ontario, Canada.
> https://neilrieck.net

Sometime I wonder if the spammers get notice of the spam complaints and make it a higher value target since the complaints are evidence that the spam is reaching eyeballs.

The spam appears to be coming from India, which doesn't need to use robots.

On 11/18/2023 9:22 AM, Arne Vajhøj wrote:
> On 11/17/2023 8:10 PM, Arne Vajhøj wrote:
>> I just did another little article.
>>
>> https://www.vajhoej.dk/arne/articles/vmsdbx.html
>>
>> providing some examples for the databases available on VMS (Rdb, MySQL,
>> SQLite, Mimer, Derby, H2, HSQLDB) in various programming languages
>> (Cobol, C, Pascal, Java, Jython, Python, PHP).
>>
>> Nothing surprising and a lot of overlap with previous
>> articles, but a different perspective.
>
> Niel Rieck replied (for some reason the post did not propagate
> to eternal-september, so this is a manual copy from Google Groups):
>
> > Two additional points.
> >
> > 1) I've done a bit of hacking with SQLite (on both OpenVMS + Linux )
> > and can inform that it should only be used in single user
> > applications. When any process issues an "update table" command, all
> > other processes are locked out.
>
> For multi user scenarios database servers are usually better than
> embedded databases.
>
> I would have thougth SQLite could only have locked some part of
> the database when doing an UPDATE, but ...
>
> > 2) Back in 2016 I received a copy of MariaDB-5.5 for OpenVMS Itanium
> > from Mark Berryman. Since 90% of our VMS stuff is written in BASIC, I
> > spent more than a few days trying to glue Mark's client code to my
> > BASIC programs (we are in the process of moving our data from RMS to
> > MariaDB). Linking the object files was fairly easy using Mark's
> > instructions. Trying to pass string arrays from C to BASIC was a
> > little more difficult. My eventual solution involved created string
> > arrays in a BASIC declared COMMON then had C employ str$get1_dx() to
> > copy the data back. I would be interested to learn if you had a better
> > method.
>
> > https://neilrieck.net/demo_vms_html/mysql_api_demo14_c.html
> > (crude c demo)
> > https://neilrieck.net/demo_vms_html/mysql_demo14_bas.html
> > (crude BASIC demo)
>
> VMS Basic is as it is and the libmysql API is what it is and
> any solution is constrained by that.
>
> I do not have any magic solution for the problem. I would
> probably have made the API differently (but differently does
> not necessarily mean better).

I could not resist trying.

This is first attempt. But I think it is a relative clean API.

$ type list.bas
program main

option type = explicit

declare integer dbcon, stmt, outparam
declare integer f1
declare string f2

%include "b.bas"

dbcon = bmysql_open("localhost", 3306, "root", "", "test")
stmt = bmysql_stmt_prepare(dbcon, "SELECT f1,f2 FROM t1")
outparam = bmysql_outparam_init(2)
call bmysql_outparam_integer(outparam, 0, f1)
call bmysql_outparam_string(outparam, 1, f2)
call bmysql_stmt_execute(stmt, 0, outparam)
while bmysql_stmt_fetch(stmt, outparam) = 0
print f1, "|" + f2 + "|"
next
call bmysql_outparam_free(outparam)
call bmysql_stmt_free(stmt)
call bmysql_close(dbcon)

end program
$ bas list
$ link list + b/opt
$ type list2.bas
program main

option type = explicit

declare integer dbcon, stmt, inparam, outparam
declare integer f1
declare string f2

%include "b.bas"

dbcon = bmysql_open("localhost", 3306, "root", "", "test")
stmt = bmysql_stmt_prepare(dbcon, "SELECT f1 FROM t1 WHERE f2 LIKE ?")
f2 = "B%"
inparam = bmysql_inparam_init(1)
call bmysql_inparam_string(inparam, 0, f2)
outparam = bmysql_outparam_init(1)
call bmysql_outparam_integer(outparam, 0, f1)
call bmysql_stmt_execute(stmt, inparam, outparam)
while bmysql_stmt_fetch(stmt, outparam) = 0
print f1
next
call bmysql_outparam_free(inparam)
call bmysql_outparam_free(outparam)
call bmysql_stmt_free(stmt)
call bmysql_close(dbcon)

end program
$ bas list2
$ link list2 + b/opt
$ type add.bas
program main

option type = explicit

declare integer dbcon, stmt, inparam
declare integer f1
declare string f2

%include "b.bas"

dbcon = bmysql_open("localhost", 3306, "root", "", "test")
stmt = bmysql_stmt_prepare(dbcon, "INSERT INTO t1 VALUES(?,?)")
f1 = 4
f2 = "DDDD"
inparam = bmysql_inparam_init(2)
call bmysql_inparam_integer(inparam, 0, f1)
call bmysql_inparam_string(inparam, 1, f2)
call bmysql_stmt_execute(stmt, inparam, 0)
call bmysql_inparam_free(inparam)
call bmysql_stmt_free(stmt)
call bmysql_close(dbcon)

end program
$ bas add
$ link add + b/opt
$ type del.bas
program main

option type = explicit

declare integer dbcon, stmt, inparam
declare integer f1

%include "b.bas"

dbcon = bmysql_open("localhost", 3306, "root", "", "test")
stmt = bmysql_stmt_prepare(dbcon, "DELETE FROM t1 WHERE f1 = ?")
f1 = 4
inparam = bmysql_inparam_init(1)
call bmysql_inparam_integer(inparam, 0, f1)
call bmysql_stmt_execute(stmt, inparam, 0)
call bmysql_inparam_free(inparam)
call bmysql_stmt_free(stmt)
call bmysql_close(dbcon)

end program
$ bas del
$ link del + b/opt
$ run list
1 |A|
2 |BB|
3 |CCC|
$ run list2
2
$ run add
$ run list
1 |A|
2 |BB|
3 |CCC|
4 |DDDD|
$ run list2
2
$ run del
$ run list
1 |A|
2 |BB|
3 |CCC|
$ run list2
2

Arne

On 11/18/2023 4:05 PM, David Jones wrote:
> On Friday, November 17, 2023 at 8:10:25 PM UTC-5, Arne Vajhøj wrote:
>> I just did another little article.
>>
>> https://www.vajhoej.dk/arne/articles/vmsdbx.html
>>
>> providing some examples for the databases available on VMS (Rdb, MySQL,
>> SQLite, Mimer, Derby, H2, HSQLDB) in various programming languages
>> (Cobol, C, Pascal, Java, Jython, Python, PHP).
>>
>> Nothing surprising and a lot of overlap with previous
>> articles, but a different perspective.
>>
> Python can use the pysqlite module to interface to SQLite using Python's
> DB API. This API supports several other databases as well.

Python DB API 2.0 is covered under standard API.

Python example with Rdb and SQLite demo. And MySQL present
but out commented because module not installed on the test system.
And Jython with 6 databases demoed.

Arne

On 11/18/23 5:47 PM, Arne Vajhøj wrote:
> On 11/18/2023 9:22 AM, Arne Vajhøj wrote:
>> On 11/17/2023 8:10 PM, Arne Vajhøj wrote:
>>> I just did another little article.
>>>
>>> https://www.vajhoej.dk/arne/articles/vmsdbx.html
>>>
>>> providing some examples for the databases available on VMS (Rdb, MySQL,
>>> SQLite, Mimer, Derby, H2, HSQLDB) in various programming languages
>>> (Cobol, C, Pascal, Java, Jython, Python, PHP).
>>>
>>> Nothing surprising and a lot of overlap with previous
>>> articles, but a different perspective.
>>
>> Niel Rieck replied (for some reason the post did not propagate
>> to eternal-september, so this is a manual copy from Google Groups):
>>
>>  > Two additional points.
>>  >
>>  > 1) I've done a bit of hacking with SQLite (on both OpenVMS + Linux )
>>  > and can inform that it should only be used in single user
>>  > applications. When any process issues an "update table" command, all
>>  > other processes are locked out.
>>
>> For multi user scenarios database servers are usually better than
>> embedded databases.
>>
>> I would have thougth SQLite could only have locked some part of
>> the database when doing an UPDATE, but ...
>>
>>  > 2) Back in 2016 I received a copy of MariaDB-5.5 for OpenVMS Itanium
>>  > from Mark Berryman. Since 90% of our VMS stuff is written in BASIC, I
>>  > spent more than a few days trying to glue Mark's client code to my
>>  > BASIC programs (we are in the process of moving our data from RMS to
>>  > MariaDB). Linking the object files was fairly easy using Mark's
>>  > instructions. Trying to pass string arrays from C to BASIC was a
>>  > little more difficult. My eventual solution involved created string
>>  > arrays in a BASIC declared COMMON then had C employ str$get1_dx() to
>>  > copy the data back. I would be interested to learn if you had a better
>>  > method.
>>
>>  > https://neilrieck.net/demo_vms_html/mysql_api_demo14_c.html
>>  > (crude c demo)
>>  > https://neilrieck.net/demo_vms_html/mysql_demo14_bas.html
>>  > (crude BASIC demo)
>>
>> VMS Basic is as it is and the libmysql API is what it is and
>> any solution is constrained by that.
>>
>> I do not have any magic solution for the problem. I would
>> probably have made the API differently (but differently does
>> not necessarily mean better).
>
> I could not resist trying.
>
> This is first attempt. But I think it is a relative clean API.
>
> $ type list.bas
> program main
>
> option type = explicit
>
> declare integer dbcon, stmt, outparam
> declare integer f1
> declare string f2
>
> %include "b.bas"
>
> dbcon = bmysql_open("localhost", 3306, "root", "", "test")
> stmt = bmysql_stmt_prepare(dbcon, "SELECT f1,f2 FROM t1")
> outparam = bmysql_outparam_init(2)
> call bmysql_outparam_integer(outparam, 0, f1)
> call bmysql_outparam_string(outparam, 1, f2)
> call bmysql_stmt_execute(stmt, 0, outparam)
> while bmysql_stmt_fetch(stmt, outparam) = 0
>    print f1, "|" + f2 + "|"
> next
> call bmysql_outparam_free(outparam)
> call bmysql_stmt_free(stmt)
> call bmysql_close(dbcon)
>
> end program
> $ bas list
> $ link list + b/opt
> $ type list2.bas
> program main
>
> option type = explicit
>
> declare integer dbcon, stmt, inparam, outparam
> declare integer f1
> declare string f2
>
> %include "b.bas"
>
> dbcon = bmysql_open("localhost", 3306, "root", "", "test")
> stmt = bmysql_stmt_prepare(dbcon, "SELECT f1 FROM t1 WHERE f2 LIKE ?")
> f2 = "B%"
> inparam = bmysql_inparam_init(1)
> call bmysql_inparam_string(inparam, 0, f2)
> outparam = bmysql_outparam_init(1)
> call bmysql_outparam_integer(outparam, 0, f1)
> call bmysql_stmt_execute(stmt, inparam, outparam)
> while bmysql_stmt_fetch(stmt, outparam) = 0
>    print f1
> next
> call bmysql_outparam_free(inparam)
> call bmysql_outparam_free(outparam)
> call bmysql_stmt_free(stmt)
> call bmysql_close(dbcon)
>
> end program
> $ bas list2
> $ link list2 + b/opt
> $ type add.bas
> program main
>
> option type = explicit
>
> declare integer dbcon, stmt, inparam
> declare integer f1
> declare string f2
>
> %include "b.bas"
>
> dbcon = bmysql_open("localhost", 3306, "root", "", "test")
> stmt = bmysql_stmt_prepare(dbcon, "INSERT INTO t1 VALUES(?,?)")
> f1 = 4
> f2 = "DDDD"
> inparam = bmysql_inparam_init(2)
> call bmysql_inparam_integer(inparam, 0, f1)
> call bmysql_inparam_string(inparam, 1, f2)
> call bmysql_stmt_execute(stmt, inparam, 0)
> call bmysql_inparam_free(inparam)
> call bmysql_stmt_free(stmt)
> call bmysql_close(dbcon)
>
> end program
> $ bas add
> $ link add + b/opt
> $ type del.bas
> program main
>
> option type = explicit
>
> declare integer dbcon, stmt, inparam
> declare integer f1
>
> %include "b.bas"
>
> dbcon = bmysql_open("localhost", 3306, "root", "", "test")
> stmt = bmysql_stmt_prepare(dbcon, "DELETE FROM t1 WHERE f1 = ?")
> f1 = 4
> inparam = bmysql_inparam_init(1)
> call bmysql_inparam_integer(inparam, 0, f1)
> call bmysql_stmt_execute(stmt, inparam, 0)
> call bmysql_inparam_free(inparam)
> call bmysql_stmt_free(stmt)
> call bmysql_close(dbcon)
>
> end program
> $ bas del
> $ link del + b/opt
> $ run list
>  1            |A|
>  2            |BB|
>  3            |CCC|
> $ run list2
>  2
> $ run add
> $ run list
>  1            |A|
>  2            |BB|
>  3            |CCC|
>  4            |DDDD|
> $ run list2
>  2
> $ run del
> $ run list
>  1            |A|
>  2            |BB|
>  3            |CCC|
> $ run list2
>  2

On a semi-related note, I once wrote wrappers around some of the socket
routines so I could call them from BASIC. recv looked like this:

#define BASIC_True -1
#define BASIC_False 0

int
mytcp_recv( int *sockfd,
struct dsc$descriptor_d *msg_dsc,
int *bytes_read,
struct dsc$descriptor_d *errmsg_dsc ) {

*bytes_read = recv( *sockfd,
msg_dsc->dsc$a_pointer,
msg_dsc->dsc$w_length,
0 );

if ( *bytes_read < 0 ) {
/* other error reporting */
return(BASIC_False);
}

return(BASIC_True);
}

Call it from BASIC like so:

EXTERNAL LONG FUNCTION MYTCP_RECV( LONG BY REF, STRING BY DESC, LONG
BY REF, STRING BY DESC )
SOCKET_SUCCESS = MYTCP_RECV( SOCKET, MESSAGE, DATA_LENGTH, ERRMSG )

I think it took me a bit to wise up to the fact that BASIC's descriptors
are dynamic and needed the dsc$descriptor_d declarations.

On 11/18/2023 7:04 PM, Craig A. Berry wrote:
> On a semi-related note, I once wrote wrappers around some of the socket
> routines so I could call them from BASIC.  recv looked like this:
>
> #define BASIC_True -1
> #define BASIC_False 0
>
> int
> mytcp_recv( int *sockfd,
>              struct dsc$descriptor_d *msg_dsc,
>              int *bytes_read,
>              struct dsc$descriptor_d *errmsg_dsc ) {
>
>     *bytes_read = recv( *sockfd,
>                         msg_dsc->dsc$a_pointer,
>                         msg_dsc->dsc$w_length,
>                         0 );
>
>     if ( *bytes_read < 0 ) {
>         /* other error reporting */
>         return(BASIC_False);
>     }
>
>     return(BASIC_True);
> }
>
> Call it from BASIC like so:
>
>   EXTERNAL LONG FUNCTION MYTCP_RECV(  LONG BY REF, STRING BY DESC, LONG
> BY REF, STRING BY DESC )
>   SOCKET_SUCCESS = MYTCP_RECV( SOCKET, MESSAGE, DATA_LENGTH, ERRMSG )
>
> I think it took me a bit to wise up to the fact that BASIC's descriptors
> are dynamic and needed the dsc$descriptor_d declarations.

I know that.

For moving data into the Basic string I use:

static void bstr(char *buf, int buflen, struct dsc$descriptor_d *d)
{ lib$sget1_dd(&buflen, d);
d->dsc$b_dtype = DSC$K_DTYPE_T;
memcpy(d->dsc$a_pointer, buf, buflen);
}

Some code I had on the shelf. Not sure where I got it from.

Arne

On Saturday, November 18, 2023 at 6:47:22 PM UTC-5, Arne Vajhøj wrote:
> On 11/18/2023 9:22 AM, Arne Vajhøj wrote:
> > On 11/17/2023 8:10 PM, Arne Vajhøj wrote:
> >> I just did another little article.
> >>
> >> https://www.vajhoej.dk/arne/articles/vmsdbx.html
> >>
> >> providing some examples for the databases available on VMS (Rdb, MySQL,
> >> SQLite, Mimer, Derby, H2, HSQLDB) in various programming languages
> >> (Cobol, C, Pascal, Java, Jython, Python, PHP).
> >>
> >> Nothing surprising and a lot of overlap with previous
> >> articles, but a different perspective.
> >
> > Niel Rieck replied (for some reason the post did not propagate
> > to eternal-september, so this is a manual copy from Google Groups):
> >
> > > Two additional points.
> > >
> > > 1) I've done a bit of hacking with SQLite (on both OpenVMS + Linux )
> > > and can inform that it should only be used in single user
> > > applications. When any process issues an "update table" command, all
> > > other processes are locked out.
> >
> > For multi user scenarios database servers are usually better than
> > embedded databases.
> >
> > I would have thougth SQLite could only have locked some part of
> > the database when doing an UPDATE, but ...
> >
> > > 2) Back in 2016 I received a copy of MariaDB-5.5 for OpenVMS Itanium
> > > from Mark Berryman. Since 90% of our VMS stuff is written in BASIC, I
> > > spent more than a few days trying to glue Mark's client code to my
> > > BASIC programs (we are in the process of moving our data from RMS to
> > > MariaDB). Linking the object files was fairly easy using Mark's
> > > instructions. Trying to pass string arrays from C to BASIC was a
> > > little more difficult. My eventual solution involved created string
> > > arrays in a BASIC declared COMMON then had C employ str$get1_dx() to
> > > copy the data back. I would be interested to learn if you had a better
> > > method.
> >
> > > https://neilrieck.net/demo_vms_html/mysql_api_demo14_c.html
> > > (crude c demo)
> > > https://neilrieck.net/demo_vms_html/mysql_demo14_bas.html
> > > (crude BASIC demo)
> >
> > VMS Basic is as it is and the libmysql API is what it is and
> > any solution is constrained by that.
> >
> > I do not have any magic solution for the problem. I would
> > probably have made the API differently (but differently does
> > not necessarily mean better).
> I could not resist trying.
>
> This is first attempt. But I think it is a relative clean API.
>
> $ type list.bas
> program main
>
> option type = explicit
>
> declare integer dbcon, stmt, outparam
> declare integer f1
> declare string f2
>
> %include "b.bas"
>
> dbcon = bmysql_open("localhost", 3306, "root", "", "test")
> stmt = bmysql_stmt_prepare(dbcon, "SELECT f1,f2 FROM t1")
> outparam = bmysql_outparam_init(2)
> call bmysql_outparam_integer(outparam, 0, f1)
> call bmysql_outparam_string(outparam, 1, f2)
> call bmysql_stmt_execute(stmt, 0, outparam)
> while bmysql_stmt_fetch(stmt, outparam) = 0
> print f1, "|" + f2 + "|"
> next
> call bmysql_outparam_free(outparam)
> call bmysql_stmt_free(stmt)
> call bmysql_close(dbcon)
>
> end program
> $ bas list
> $ link list + b/opt
> $ type list2.bas
> program main
>
> option type = explicit
>
> declare integer dbcon, stmt, inparam, outparam
> declare integer f1
> declare string f2
>
> %include "b.bas"
>
> dbcon = bmysql_open("localhost", 3306, "root", "", "test")
> stmt = bmysql_stmt_prepare(dbcon, "SELECT f1 FROM t1 WHERE f2 LIKE ?")
> f2 = "B%"
> inparam = bmysql_inparam_init(1)
> call bmysql_inparam_string(inparam, 0, f2)
> outparam = bmysql_outparam_init(1)
> call bmysql_outparam_integer(outparam, 0, f1)
> call bmysql_stmt_execute(stmt, inparam, outparam)
> while bmysql_stmt_fetch(stmt, outparam) = 0
> print f1
> next
> call bmysql_outparam_free(inparam)
> call bmysql_outparam_free(outparam)
> call bmysql_stmt_free(stmt)
> call bmysql_close(dbcon)
>
> end program
> $ bas list2
> $ link list2 + b/opt
> $ type add.bas
> program main
>
> option type = explicit
>
> declare integer dbcon, stmt, inparam
> declare integer f1
> declare string f2
>
> %include "b.bas"
>
> dbcon = bmysql_open("localhost", 3306, "root", "", "test")
> stmt = bmysql_stmt_prepare(dbcon, "INSERT INTO t1 VALUES(?,?)")
> f1 = 4
> f2 = "DDDD"
> inparam = bmysql_inparam_init(2)
> call bmysql_inparam_integer(inparam, 0, f1)
> call bmysql_inparam_string(inparam, 1, f2)
> call bmysql_stmt_execute(stmt, inparam, 0)
> call bmysql_inparam_free(inparam)
> call bmysql_stmt_free(stmt)
> call bmysql_close(dbcon)
>
> end program
> $ bas add
> $ link add + b/opt
> $ type del.bas
> program main
>
> option type = explicit
>
> declare integer dbcon, stmt, inparam
> declare integer f1
>
> %include "b.bas"
>
> dbcon = bmysql_open("localhost", 3306, "root", "", "test")
> stmt = bmysql_stmt_prepare(dbcon, "DELETE FROM t1 WHERE f1 = ?")
> f1 = 4
> inparam = bmysql_inparam_init(1)
> call bmysql_inparam_integer(inparam, 0, f1)
> call bmysql_stmt_execute(stmt, inparam, 0)
> call bmysql_inparam_free(inparam)
> call bmysql_stmt_free(stmt)
> call bmysql_close(dbcon)
>
> end program
> $ bas del
> $ link del + b/opt
> $ run list
> 1 |A|
> 2 |BB|
> 3 |CCC|
> $ run list2
> 2
> $ run add
> $ run list
> 1 |A|
> 2 |BB|
> 3 |CCC|
> 4 |DDDD|
> $ run list2
> 2
> $ run del
> $ run list
> 1 |A|
> 2 |BB|
> 3 |CCC|
> $ run list2
> 2
>
> Arne

Could you post the included code: "b.bas"

Neil

On 11/19/2023 4:47 AM, Neil Rieck wrote:
> On Saturday, November 18, 2023 at 6:47:22 PM UTC-5, Arne Vajhøj wrote:
>> On 11/18/2023 9:22 AM, Arne Vajhøj wrote:
>>> VMS Basic is as it is and the libmysql API is what it is and
>>> any solution is constrained by that.
>>>
>>> I do not have any magic solution for the problem. I would
>>> probably have made the API differently (but differently does
>>> not necessarily mean better).
>> I could not resist trying.
>>
>> This is first attempt. But I think it is a relative clean API.

> Could you post the included code: "b.bas"

B.BAS is not so interesting:

external integer function bmysql_open(string, integer, string, string,
string)
external integer function bmysql_stmt_prepare(integer, string)
external integer function bmysql_outparam_init(integer)
external integer function bmysql_inparam_init(integer)
external sub bmysql_outparam_integer(integer, integer, integer)
external sub bmysql_inparam_integer(integer, integer, integer)
external sub bmysql_outparam_string(integer, integer, string)
external sub bmysql_inparam_string(integer, integer, string)
external sub bmysql_stmt_execute(integer, integer, integer)
external integer function bmysql_stmt_fetch(integer, integer)
external sub bmysql_outparam_free(integer)
external sub bmysql_inparam_free(integer)
external sub bmysql_stmt_free(integer)
external sub bmysql_close(integer)

B2C.C has the interesting stuff:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include <descrip.h>
#include <lib$routines.h>

#define SOCKET int
#include <mysql.h>

#define MAX_LEN 32000

struct b_param
{ int n;
struct dsc$descriptor_d **bstr;
MYSQL_BIND *bind;
};

static char *cstr(struct dsc$descriptor_d *s)
{ char *s2 = malloc(s->dsc$w_length + 1);
memcpy(s2, s->dsc$a_pointer, s->dsc$w_length);
s2[s->dsc$w_length] = 0;
return s2;
}

static void bstr(char *buf, int buflen, struct dsc$descriptor_d *d)
{ lib$sget1_dd(&buflen, d);
d->dsc$b_dtype = DSC$K_DTYPE_T;
memcpy(d->dsc$a_pointer, buf, buflen);
}

static MYSQL *realcon(int *con)
{ return (MYSQL *)(*con);
}

static MYSQL_STMT *realstmt(int *stmt)
{ return (MYSQL_STMT *)(*stmt);
}

static struct b_param *realparam(int *param)
{ return (struct b_param *)(*param);
}

int BMYSQL_OPEN(struct dsc$descriptor_d *host,
int *port,
struct dsc$descriptor_d *usr,
struct dsc$descriptor_d *pwd,
struct dsc$descriptor_d *db)
{ char *host2 = cstr(host);
char *usr2 = cstr(usr);
char *pwd2 = cstr(pwd);
char *db2 = cstr(db);
MYSQL *con = mysql_init(NULL);
con = mysql_real_connect(con, host2, usr2, pwd2, db2, *port, NULL, 0);
free(host2);
free(usr2);
free(pwd2);
free(db2);
return (int)con;
}

int BMYSQL_STMT_PREPARE(int *con, struct dsc$descriptor_d *sql)
{ char *sql2 = cstr(sql);
MYSQL_STMT *stmt = mysql_stmt_init(realcon(con));
int stat = mysql_stmt_prepare(stmt, sql2, strlen(sql2));
if(stat != 0) printf("mysql_stmt_prepare error : %s\n",
mysql_error(realcon(con)));
free(sql2);
return (int)stmt;
}

int BMYSQL_OUTPARAM_INIT(int *nparam)
{ struct b_param *p = malloc(sizeof(struct b_param));
p->n = *nparam;
p->bstr = malloc(*nparam * sizeof(struct dsc$descriptor_d));
p->bind = malloc(*nparam * sizeof(MYSQL_BIND));
return (int)p;
}

int BMYSQL_INPARAM_INIT(int *nparam)
{ struct b_param *p = malloc(sizeof(struct b_param));
p->n = *nparam;
p->bstr = NULL;
p->bind = malloc(*nparam * sizeof(MYSQL_BIND));
return (int)p;
}

void BMYSQL_OUTPARAM_INTEGER(int *param, int *ix, int *val)
{ struct b_param *p = realparam(param);
p->bstr[*ix] = NULL;
memset(&p->bind[*ix], 0, sizeof(MYSQL_BIND));
p->bind[*ix].buffer_type = MYSQL_TYPE_LONG;
p->bind[*ix].buffer = (char *)val;
p->bind[*ix].buffer_length = sizeof(int);
}

void BMYSQL_INPARAM_INTEGER(int *param, int *ix, int *val)
{ struct b_param *p = realparam(param);
memset(&p->bind[*ix], 0, sizeof(MYSQL_BIND));
p->bind[*ix].buffer_type = MYSQL_TYPE_LONG;
p->bind[*ix].buffer = (char *)val;
p->bind[*ix].buffer_length = sizeof(int);
}

void BMYSQL_OUTPARAM_STRING(int *param, int *ix, struct dsc$descriptor_d
*val)
{ struct b_param *p = realparam(param);
memset(&p->bind[*ix], 0, sizeof(MYSQL_BIND));
p->bstr[*ix] = val;
p->bind[*ix].buffer_type = MYSQL_TYPE_STRING;
p->bind[*ix].buffer = malloc(MAX_LEN);
p->bind[*ix].buffer_length = MAX_LEN;
p->bind[*ix].length = (unsigned long *)malloc(sizeof(unsigned long));
}

void BMYSQL_INPARAM_STRING(int *param, int *ix, struct dsc$descriptor_d
*val)
{ struct b_param *p = realparam(param);
memset(&p->bind[*ix], 0, sizeof(MYSQL_BIND));
p->bind[*ix].buffer_type = MYSQL_TYPE_STRING;
p->bind[*ix].buffer = val->dsc$a_pointer;
p->bind[*ix].buffer_length = val->dsc$w_length;
}

void BMYSQL_STMT_EXECUTE(int *stmt, int *inparam, int *outparam)
{ int stat;
struct b_param *pin = realparam(inparam);
struct b_param *pout = realparam(outparam);
if(*inparam != 0)
{
stat = mysql_stmt_bind_param(realstmt(stmt), pin->bind);
if(stat != 0) printf("mysql_stmt_bind_param error : %s\n",
mysql_stmt_error(realstmt(stmt)));
}
stat = mysql_stmt_execute(realstmt(stmt));
if(stat != 0) printf("mysql_stmt_execute error : %s\n",
mysql_stmt_error(realstmt(stmt)));
if(*outparam != 0)
{
stat = mysql_stmt_bind_result(realstmt(stmt), pout->bind);
if(stat != 0) printf("mysql_stmt_bind_result error : %s\n",
mysql_stmt_error(realstmt(stmt)));
}
stat = mysql_stmt_store_result(realstmt(stmt));
if(stat != 0) printf("mysql_stmt_store_result error : %s\n",
mysql_stmt_error(realstmt(stmt)));
}

int BMYSQL_STMT_FETCH(int *stmt, int *param)
{ struct b_param *p = realparam(param);
int stat = mysql_stmt_fetch(realstmt(stmt));
for(int i = 0; i < p->n; i++)
{
if(p->bind[i].buffer_type == MYSQL_TYPE_STRING)
{
char *buf = (char *)p->bind[i].buffer;
int buflen = (int)*(p->bind[i].length);
bstr(buf, buflen, p->bstr[i]);
}
}
return stat;
}

void BMYSQL_OUTPARAM_FREE(int *param)
{ struct b_param *p = realparam(param);
for(int i = 0; i < p->n; i++)
{
if(p->bind[i].buffer_type == MYSQL_TYPE_STRING)
{
free(p->bind[i].buffer);
free(p->bind[i].length);
}
}
free(p->bind);
free(p->bstr);
free(p);
}

void BMYSQL_INPARAM_FREE(int *param)
{ struct b_param *p = realparam(param);
free(p->bind);
free(p);
}

void BMYSQL_STMT_FREE(int *stmt)
{ mysql_stmt_free_result(realstmt(stmt));
}

void BMYSQL_CLOSE(int *con)
{ mysql_close(realcon(con));
}

Arne

On 2023-11-18 14:22:52 +0000, Arne Vajhøj said:

> On 11/17/2023 8:10 PM, Arne Vajhøj wrote:
>
> Niel Rieck replied (for some reason the post did not propagate to
> eternal-september, so this is a manual copy from Google Groups):

Probably caught in the Google Groups spam.

>> Two additional points.
>>
>> 1) I've done a bit of hacking with SQLite (on both OpenVMS + Linux )
>> and can inform that it should only be used in single user applications.
>> When any process issues an "update table" command, all other processes
>> are locked out.
>
> For multi user scenarios database servers are usually better than
> embedded databases.

As with many things in IT, that depends.

Expectations and related sizes can also differ. What can be considered
a small database for SQLite can potentially be considered a large
database for OpenVMS, for instance.

Expectations? SQLite tops out at 256 TiB databases, while OpenVMS file
storage tops out at 2 TiB files absent 'heroic' efforts.

> I would have thougth SQLite could only have locked some part of the
> database when doing an UPDATE, but ...

If you ask nicely, SQLite will defer the locking until the commit:

https://sqlite.org/cgi/src/doc/begin-concurrent/doc/begin_concurrent.md

Otherwise, SQLite picks a simpler approach to database locking,
permitting one concurrent writer.

That section also includes suggestions around how to arbitrate update
access from within the application, when (if?) that becomes necessary.

--
Pure Personal Opinion | HoffmanLabs LLC

On Sunday, November 19, 2023 at 12:37:17 PM UTC-5, Stephen Hoffman wrote:
> If you ask nicely, SQLite will defer the locking until the commit:
>
> https://sqlite.org/cgi/src/doc/begin-concurrent/doc/begin_concurrent.md
>
> Otherwise, SQLite picks a simpler approach to database locking,
> permitting one concurrent writer.

"BEGIN CONCURRENT" is part of an experimental 'high concurrency' development
branch and is not in the mainline code published by SQLite.org. If you try it you just
get a syntax error.

Use of WAL mode (write-ahead logging) can alleviate some of the concurrent write
issues. It wants to use shared memory to coordinate between processes, however,
posing an issue for databases residing on shared disks in a cluster.

On Sunday, November 19, 2023 at 1:39:35 PM UTC-5, David Jones wrote:
> On Sunday, November 19, 2023 at 12:37:17 PM UTC-5, Stephen Hoffman wrote:
> > If you ask nicely, SQLite will defer the locking until the commit:
> >
> > https://sqlite.org/cgi/src/doc/begin-concurrent/doc/begin_concurrent.md
> >
> > Otherwise, SQLite picks a simpler approach to database locking,
> > permitting one concurrent writer.
> "BEGIN CONCURRENT" is part of an experimental 'high concurrency' development
> branch and is not in the mainline code published by SQLite.org. If you try it you just
> get a syntax error.
>
> Use of WAL mode (write-ahead logging) can alleviate some of the concurrent write
> issues. It wants to use shared memory to coordinate between processes, however,
> posing an issue for databases residing on shared disks in a cluster.

I have only done a small amount of SQLite programming on OpenVMS. In fact, I suppose you could say that it was only at the evaluation level because after I ran into some obvious problems, I switched over to MySQL / MariaDB then never looked back.

Now that is not to say that this is a garbage product. Most Linux people know that SQLite is employed by RPM/YUM/DNF to keep track of package dependencies.

As I understand it, SQLlite is also employed on most smart phones, and there are probably more of these in the world than laptops, desktops, towers and servers.

Neil Rieck
Waterloo, Ontario, Canada.
https://neilrieck.net

On Sunday, November 19, 2023 at 11:50:58 AM UTC-5, Arne Vajhøj wrote:
> On 11/19/2023 4:47 AM, Neil Rieck wrote:
> > On Saturday, November 18, 2023 at 6:47:22 PM UTC-5, Arne Vajhøj wrote:
> >> On 11/18/2023 9:22 AM, Arne Vajhøj wrote:
> >>> VMS Basic is as it is and the libmysql API is what it is and
> >>> any solution is constrained by that.
> >>>
> >>> I do not have any magic solution for the problem. I would
> >>> probably have made the API differently (but differently does
> >>> not necessarily mean better).
> >> I could not resist trying.
> >>
> >> This is first attempt. But I think it is a relative clean API.
> > Could you post the included code: "b.bas"
> B.BAS is not so interesting:
>
> external integer function bmysql_open(string, integer, string, string,
> string)
> external integer function bmysql_stmt_prepare(integer, string)
> external integer function bmysql_outparam_init(integer)
> external integer function bmysql_inparam_init(integer)
> external sub bmysql_outparam_integer(integer, integer, integer)
> external sub bmysql_inparam_integer(integer, integer, integer)
> external sub bmysql_outparam_string(integer, integer, string)
> external sub bmysql_inparam_string(integer, integer, string)
> external sub bmysql_stmt_execute(integer, integer, integer)
> external integer function bmysql_stmt_fetch(integer, integer)
> external sub bmysql_outparam_free(integer)
> external sub bmysql_inparam_free(integer)
> external sub bmysql_stmt_free(integer)
> external sub bmysql_close(integer)
>
> B2C.C has the interesting stuff:
>
> #include <stdio.h>
> #include <stdlib.h>
> #include <string.h>
>
> #include <descrip.h>
> #include <lib$routines.h>
>
> #define SOCKET int
> #include <mysql.h>
>
> #define MAX_LEN 32000
>
> struct b_param
> {
> int n;
> struct dsc$descriptor_d **bstr;
> MYSQL_BIND *bind;
> };
>
> static char *cstr(struct dsc$descriptor_d *s)
> {
> char *s2 = malloc(s->dsc$w_length + 1);
> memcpy(s2, s->dsc$a_pointer, s->dsc$w_length);
> s2[s->dsc$w_length] = 0;
> return s2;
> }
>
> static void bstr(char *buf, int buflen, struct dsc$descriptor_d *d)
> {
> lib$sget1_dd(&buflen, d);
> d->dsc$b_dtype = DSC$K_DTYPE_T;
> memcpy(d->dsc$a_pointer, buf, buflen);
> }
> static MYSQL *realcon(int *con)
> {
> return (MYSQL *)(*con);
> }
>
> static MYSQL_STMT *realstmt(int *stmt)
> {
> return (MYSQL_STMT *)(*stmt);
> }
>
> static struct b_param *realparam(int *param)
> {
> return (struct b_param *)(*param);
> }
>
> int BMYSQL_OPEN(struct dsc$descriptor_d *host,
> int *port,
> struct dsc$descriptor_d *usr,
> struct dsc$descriptor_d *pwd,
> struct dsc$descriptor_d *db)
> {
> char *host2 = cstr(host);
> char *usr2 = cstr(usr);
> char *pwd2 = cstr(pwd);
> char *db2 = cstr(db);
> MYSQL *con = mysql_init(NULL);
> con = mysql_real_connect(con, host2, usr2, pwd2, db2, *port, NULL, 0);
> free(host2);
> free(usr2);
> free(pwd2);
> free(db2);
> return (int)con;
> }
>
> int BMYSQL_STMT_PREPARE(int *con, struct dsc$descriptor_d *sql)
> {
> char *sql2 = cstr(sql);
> MYSQL_STMT *stmt = mysql_stmt_init(realcon(con));
> int stat = mysql_stmt_prepare(stmt, sql2, strlen(sql2));
> if(stat != 0) printf("mysql_stmt_prepare error : %s\n",
> mysql_error(realcon(con)));
> free(sql2);
> return (int)stmt;
> }
>
> int BMYSQL_OUTPARAM_INIT(int *nparam)
> {
> struct b_param *p = malloc(sizeof(struct b_param));
> p->n = *nparam;
> p->bstr = malloc(*nparam * sizeof(struct dsc$descriptor_d));
> p->bind = malloc(*nparam * sizeof(MYSQL_BIND));
> return (int)p;
> }
>
> int BMYSQL_INPARAM_INIT(int *nparam)
> {
> struct b_param *p = malloc(sizeof(struct b_param));
> p->n = *nparam;
> p->bstr = NULL;
> p->bind = malloc(*nparam * sizeof(MYSQL_BIND));
> return (int)p;
> }
>
> void BMYSQL_OUTPARAM_INTEGER(int *param, int *ix, int *val)
> {
> struct b_param *p = realparam(param);
> p->bstr[*ix] = NULL;
> memset(&p->bind[*ix], 0, sizeof(MYSQL_BIND));
> p->bind[*ix].buffer_type = MYSQL_TYPE_LONG;
> p->bind[*ix].buffer = (char *)val;
> p->bind[*ix].buffer_length = sizeof(int);
> }
>
> void BMYSQL_INPARAM_INTEGER(int *param, int *ix, int *val)
> {
> struct b_param *p = realparam(param);
> memset(&p->bind[*ix], 0, sizeof(MYSQL_BIND));
> p->bind[*ix].buffer_type = MYSQL_TYPE_LONG;
> p->bind[*ix].buffer = (char *)val;
> p->bind[*ix].buffer_length = sizeof(int);
> }
>
> void BMYSQL_OUTPARAM_STRING(int *param, int *ix, struct dsc$descriptor_d
> *val)
> {
> struct b_param *p = realparam(param);
> memset(&p->bind[*ix], 0, sizeof(MYSQL_BIND));
> p->bstr[*ix] = val;
> p->bind[*ix].buffer_type = MYSQL_TYPE_STRING;
> p->bind[*ix].buffer = malloc(MAX_LEN);
> p->bind[*ix].buffer_length = MAX_LEN;
> p->bind[*ix].length = (unsigned long *)malloc(sizeof(unsigned long));
> }
>
> void BMYSQL_INPARAM_STRING(int *param, int *ix, struct dsc$descriptor_d
> *val)
> {
> struct b_param *p = realparam(param);
> memset(&p->bind[*ix], 0, sizeof(MYSQL_BIND));
> p->bind[*ix].buffer_type = MYSQL_TYPE_STRING;
> p->bind[*ix].buffer = val->dsc$a_pointer;
> p->bind[*ix].buffer_length = val->dsc$w_length;
> }
>
> void BMYSQL_STMT_EXECUTE(int *stmt, int *inparam, int *outparam)
> {
> int stat;
> struct b_param *pin = realparam(inparam);
> struct b_param *pout = realparam(outparam);
> if(*inparam != 0)
> {
> stat = mysql_stmt_bind_param(realstmt(stmt), pin->bind);
> if(stat != 0) printf("mysql_stmt_bind_param error : %s\n",
> mysql_stmt_error(realstmt(stmt)));
> }
> stat = mysql_stmt_execute(realstmt(stmt));
> if(stat != 0) printf("mysql_stmt_execute error : %s\n",
> mysql_stmt_error(realstmt(stmt)));
> if(*outparam != 0)
> {
> stat = mysql_stmt_bind_result(realstmt(stmt), pout->bind);
> if(stat != 0) printf("mysql_stmt_bind_result error : %s\n",
> mysql_stmt_error(realstmt(stmt)));
> }
> stat = mysql_stmt_store_result(realstmt(stmt));
> if(stat != 0) printf("mysql_stmt_store_result error : %s\n",
> mysql_stmt_error(realstmt(stmt)));
> }
>
> int BMYSQL_STMT_FETCH(int *stmt, int *param)
> {
> struct b_param *p = realparam(param);
> int stat = mysql_stmt_fetch(realstmt(stmt));
> for(int i = 0; i < p->n; i++)
> {
> if(p->bind[i].buffer_type == MYSQL_TYPE_STRING)
> {
> char *buf = (char *)p->bind[i].buffer;
> int buflen = (int)*(p->bind[i].length);
> bstr(buf, buflen, p->bstr[i]);
> }
> }
> return stat;
> }
>
> void BMYSQL_OUTPARAM_FREE(int *param)
> {
> struct b_param *p = realparam(param);
> for(int i = 0; i < p->n; i++)
> {
> if(p->bind[i].buffer_type == MYSQL_TYPE_STRING)
> {
> free(p->bind[i].buffer);
> free(p->bind[i].length);
> }
> }
> free(p->bind);
> free(p->bstr);
> free(p);
> }
>
> void BMYSQL_INPARAM_FREE(int *param)
> {
> struct b_param *p = realparam(param);
> free(p->bind);
> free(p);
> }
>
> void BMYSQL_STMT_FREE(int *stmt)
> {
> mysql_stmt_free_result(realstmt(stmt));
> }
>
> void BMYSQL_CLOSE(int *con)
> {
> mysql_close(realcon(con));
> }
>
> Arne

Thanks

Neil

On 11/19/2023 2:17 PM, Neil Rieck wrote:
> On Sunday, November 19, 2023 at 1:39:35 PM UTC-5, David Jones wrote:
>> On Sunday, November 19, 2023 at 12:37:17 PM UTC-5, Stephen Hoffman wrote:
>>> If you ask nicely, SQLite will defer the locking until the commit:
>>>
>>> https://sqlite.org/cgi/src/doc/begin-concurrent/doc/begin_concurrent.md
>>>
>>> Otherwise, SQLite picks a simpler approach to database locking,
>>> permitting one concurrent writer.
>> "BEGIN CONCURRENT" is part of an experimental 'high concurrency' development
>> branch and is not in the mainline code published by SQLite.org. If you try it you just
>> get a syntax error.
>>
>> Use of WAL mode (write-ahead logging) can alleviate some of the concurrent write
>> issues. It wants to use shared memory to coordinate between processes, however,
>> posing an issue for databases residing on shared disks in a cluster.
>
> I have only done a small amount of SQLite programming on OpenVMS. In
> fact, I suppose you could say that it was only at the evaluation
> level because after I ran into some obvious problems, I switched over
> to MySQL / MariaDB then never looked back.
>
> Now that is not to say that this is a garbage product. Most Linux
> people know that SQLite is employed by RPM/YUM/DNF to keep track of
> package dependencies.
>
> As I understand it, SQLlite is also employed on most smart phones,
> and there are probably more of these in the world than laptops,
> desktops, towers and servers.
It is used by Android, iOS, macOS, some Linux and Unix, FireFox,
ThunderBird, various Adobe products, Skype, various car navigation
systems etc..

I think that most people use something that use SQLite.

SQLite is a fine product.

But as always one need to pick the right tool for the job.

SQLite and MySQL are not solutions for the same problem.

Arne

On 11/19/2023 4:00 PM, Arne Vajhøj wrote:
> On 11/19/2023 2:17 PM, Neil Rieck wrote:
>> On Sunday, November 19, 2023 at 1:39:35 PM UTC-5, David Jones wrote:
>>> On Sunday, November 19, 2023 at 12:37:17 PM UTC-5, Stephen Hoffman
>>> wrote:
>>>> If you ask nicely, SQLite will defer the locking until the commit:
>>>>
>>>> https://sqlite.org/cgi/src/doc/begin-concurrent/doc/begin_concurrent.md
>>>>
>>>> Otherwise, SQLite picks a simpler approach to database locking,
>>>> permitting one concurrent writer.
>>> "BEGIN CONCURRENT" is part of an experimental 'high concurrency'
>>> development
>>> branch and is not in the mainline code published by SQLite.org. If
>>> you try it you just
>>> get a syntax error.
>>>
>>> Use of WAL mode (write-ahead logging) can alleviate some of the
>>> concurrent write
>>> issues. It wants to use shared memory to coordinate between
>>> processes, however,
>>> posing an issue for databases residing on shared disks in a cluster.
>>
>> I have only done a small amount of SQLite programming on OpenVMS. In
>> fact, I suppose you could say that it was only at the evaluation
>> level because after I ran into some obvious problems, I switched over
>> to MySQL / MariaDB then never looked back.
>>
>> Now that is not to say that this is a garbage product. Most Linux
>> people know that SQLite is employed by  RPM/YUM/DNF to keep track of
>> package dependencies.
>>
>> As I understand it, SQLlite is also employed on most smart phones,
>> and there are probably more of these in the world than laptops,
>> desktops, towers and servers.
> It is used by Android, iOS, macOS, some Linux and Unix, FireFox,
> ThunderBird, various Adobe products, Skype, various car navigation
> systems etc..
>
> I think that most people use something that use SQLite.
>
> SQLite is a fine product.
>
> But as always one need to pick the right tool for the job.
>
> SQLite and MySQL are not solutions for the same problem.

I just did a check on my PC for what applications use SQLite.

A lot.

3 interesting ones:
* Oracle DB GDAL
* MySQL WorkBench
* PostgreSQL pgAdmin

:-)

Even if it is all about a database server then a small embedded database
can be the right tool for some task.

Arne

Den 2023-11-19 kl. 18:37, skrev Stephen Hoffman:
> On 2023-11-18 14:22:52 +0000, Arne Vajhøj said:
>
>> On 11/17/2023 8:10 PM, Arne Vajhøj wrote:
>>
>> Niel Rieck replied (for some reason the post did not propagate to
>> eternal-september, so this is a manual copy from Google Groups):
>
> Probably caught in the Google Groups spam.
>
>>>  Two additional points.
>>>
>>>  1) I've done a bit of hacking with SQLite (on both OpenVMS + Linux )
>>> and can inform that it should only be used in single user applications.
>>> When any process issues an "update table" command, all other processes
>>> are locked out.
>>
>> For multi user scenarios database servers are usually better than
>> embedded databases.
>
> As with many things in IT, that depends.
>
> Expectations and related sizes can also differ. What can be considered a
> small database for SQLite can potentially be considered a large database
> for OpenVMS, for instance.
>
> Expectations? SQLite tops out at 256 TiB databases, while OpenVMS file
> storage tops out at 2 TiB files absent 'heroic' efforts.

A single Rdb database can have 8192 storage areas (individual files)
so the max database size would be something like 16.000 TiB.

>
>> I would have thougth SQLite could only have locked some part of the
>> database when doing an UPDATE, but ...
>
> If you ask nicely, SQLite will defer the locking until the commit:
>
> https://sqlite.org/cgi/src/doc/begin-concurrent/doc/begin_concurrent.md
>
> Otherwise, SQLite picks a simpler approach to database locking, permitting
> one concurrent writer.
>
> That section also includes suggestions around how to arbitrate update
> access from within the application, when (if?) that becomes necessary.
>
>
>

On Sun, 2023-11-19 at 16:03 -0500, Arne Vajhøj wrote:
> > SQLite and MySQL are not solutions for the same problem.
>
> I just did a check on my PC for what applications use SQLite.
>
> A lot.
>
> 3 interesting ones:
> * Oracle DB GDAL
> * MySQL WorkBench
> * PostgreSQL pgAdmin
>
> :-)
>
> Even if it is all about a database server then a small embedded
> database
> can be the right tool for some task.

Android is riddled with apps that make use of SQLite3.
--
Tactical Nuclear Kittens

On 11/19/2023 11:50 AM, Arne Vajhøj wrote:
> On 11/19/2023 4:47 AM, Neil Rieck wrote:
>> On Saturday, November 18, 2023 at 6:47:22 PM UTC-5, Arne Vajhøj wrote:
>>> On 11/18/2023 9:22 AM, Arne Vajhøj wrote:
>>>> VMS Basic is as it is and the libmysql API is what it is and
>>>> any solution is constrained by that.
>>>>
>>>> I do not have any magic solution for the problem. I would
>>>> probably have made the API differently (but differently does
>>>> not necessarily mean better).
>>> I could not resist trying.
>>>
>>> This is first attempt. But I think it is a relative clean API.
>
>> Could you post the included code: "b.bas"
>
> B.BAS is not so interesting:

> B2C.C has the interesting stuff:

I just made bunch of changes (support more data types,
support CLASS S strings, some error handling in the form
of negative return values and a sub to get error message).

https://www.vajhoej.dk/arne/opensource/vms/vmsbmysql-src-v0_1.zip

Arne

On 2023-11-19 22:22:37 +0000, Jan-Erik Söderholm said:

> Den 2023-11-19 kl. 18:37, skrev Stephen Hoffman:
>> As with many things in IT, that depends.
>>
>> Expectations and related sizes can also differ. What can be considered
>> a small database for SQLite can potentially be considered a large
>> database for OpenVMS, for instance.
>>
>> Expectations? SQLite tops out at 256 TiB databases, while OpenVMS file
>> storage tops out at 2 TiB files absent 'heroic' efforts.
>
> A single Rdb database can have 8192 storage areas (individual files) so
> the max database size would be something like 16.000 TiB.

So... Heroic _and_ expensive.

--
Pure Personal Opinion | HoffmanLabs LLC