Re: How do I write directly to a memory address?

[Hyman Rosen <hyrosen@mail.com>]

On 3/2/2011 1:04 PM, Dmitry A. Kazakov wrote:
>> On 3/2/2011 12:21 PM, Dmitry A. Kazakov wrote:
>>> Of course it does. No Ada programmer would add anything to an actual
>>> parameter.
>> The GNATColl code did so.
> Because they interfaced a PostreSQL client.

But that client didn't want the quotes. The GNATColl Ada programmers
made a mistake.

> Hello world! is not a string.

Correct, neither in Ada nor in SQL. It must be quoted to become one.

>> SQL is a type of programming language, and SQL statements that
>> involve literal strings must have them be quoted.
>
> Literal strings need not be quoted. Quotes is an integral part of the
> literal. The resulting string does not have quotes.

Programmers construct pieces of SQL code, interpolating strings
into those constructs so that those interpolated strings become
string literals in the SQL code. In that created SQL code, the
interpolated strings must be quoted.

> When an Ada subprogram is called no quotes are required as in your example
> with Put_Line. A string object is passed as-is be it a literal or not.

If a programmer were to create the line of Ada dynamically and
interpolate a string into the result, he would be faced with
exactly the same problem. You seem to have a major difficulty
in understanding that programmers are creating code dynamically.


> But
> interfacing SQL requires quotes because it requires a conversion of a
> native string object to its would be equivalent textual representation in
> the SQL syntax.

That is false, because SQL interfaces also provide ways to pass
parameters separately, not through textual interpolation. It was
in this approach that GNATColl had an error, erroneously converting
to the textual representation when it was not required.

 > This is a source of errors as expected, because it is
> untyped. There is no way the program can be checked for type errors. Either
> random string represent a legal SQL statement of the semantics nobody can
> tell, or not. That is to happen at run time.

This is again false. A dynamic SQL builder in Ada could be created
that represented SQL statements using hierarchical Ada types and
objects, and produced the final SQL string representation upon
execution. In fact, GNATColl uses this approach:
     <http://www.adacore.com/wp-content/files/auto_update/gnatcoll-docs/gnatcoll.html#Writing-queries>
It also allows prepared queries with parameters, and it was in
processing those parameters that the programmers simply screwed up
and added quotes where they shouldn't have, because they got mixed
up between generating the literal code and passing the parameters.