On Tuesday, 6 December 2022 at 23:41:09 UTC, H. S. Teoh wrote:

no, you don't "need" to use std conv

Here is an alternative that doesn't allocate

Make sure to read the comments

// here notice where the functions are comming from
import std.stdio : writeln, writefln;

import core.stdc.stdio : printf;
import core.stdc.string : strlen;

const(char)* sqlite3_column_text(void*, int iCol)
{
    return "hello world";
}

void main()
{
    // printf is a libc function, it expects a null terminated string (char*)
    printf("%s\n", sqlite3_column_text(null, 0));

    // writeln is a d function, it expects a string (immutable slice of char aka immutable(char)[], a slice is T* + len)

    // so here we get the string from sqlite
    const(char)* ret = sqlite3_column_text(null, 0);


    // then we need to determine the length of the null terminated string from c
    // we can use strlen from libc

    size_t len = strlen(ret);

    // now we got a len, we can build a D string, remember, it's just a slice

    string str = cast(string) ret[0 .. len];

    writeln(str);
    writefln("%s", str);
}

On Tuesday, 6 December 2022 at 23:07:32 UTC, johannes wrote:

What you are posting here is a perfect example of unsafe code. Let's looks at it:

import std;

char *sqlite3_column_text() @system {
    return cast(char *)"the sun is shining".ptr;
}

void main() {
    printf("%s\n",sqlite3_column_text());
    writeln(sqlite3_column_text());
    writefln("%s",sqlite3_column_text());
    writefln(std.conv.to!string(sqlite3_column_text()));
}

Unsafe code has a lot of rules, which have to be carefully followed if you want to stay out of troubles. It's necessary to check the sqlite3 documentation to see who is responsible for deallocating the returned c-string and what is its expected lifetime (basically, the sqlite3 library takes care of managing the returned memory buffer and it's valid only until you make some other sqlite3 API calls).

So the use of "printf" is fine.

Direct "writeln"/"writefln" prints the pointer value, which also fine (but not what you expect).

Doing "std.conv.to!string" allocates a copy of the string, managed by the garbage collector (and this may be undesirable for performance reasons).

Doing std.conv.fromStringz as suggested by H. S. Teoh would avoid allocation, but you need to be careful with it:

    char[] s1 = fromStringz(sqlite3_column_text());

    writeln(s1); // everything is fine

    char[] s2 = fromStringz(sqlite3_column_text()); // some other sqlite3 API call

    writeln(s1); // oops, sqlite3 may have already messed up s1

Depending on what sqlite3 is doing under the hood, this may be a good example of "use after free" security issue discussed in another forum thread.

But hold on! Isn't D a safe language, supposed to protect you from danger? The answer is that it is safe, but the compiler will only watch your back if you explicitly annotate your code with a @safe attribute (and use the "-dip1000" compiler command line option too). If you do this, then the compiler will start complaining a lot. Try it:

@safe:
import std;

char *sqlite3_column_text() @system {
    return cast(char *)"the sun is shining".ptr;
}

string trusted_sqlite3_column_text() @trusted {
    return std.conv.to!string(sqlite3_column_text());
}

void main() {
    printf("%s\n",sqlite3_column_text());                // Nay!
    writeln(sqlite3_column_text());                      // Nay!
    writefln("%s",sqlite3_column_text());                // Nay!
    writefln(std.conv.to!string(sqlite3_column_text())); // Nay!
    writeln(trusted_sqlite3_column_text());              // Yay!
}

The "trusted_sqlite3_column_text" wrapper function does a memory allocation and it's up to you to decide whether this is acceptable. You are always free to write unsafe code tuned for best performance (annotated as @system or @trusted), but it's your own responsibility if you make a mistake.

BTW, maybe it's even more efficient to use sqlite3_column_blob() and sqlite3_column_bytes() for retrieving the column text as a string?

On Wednesday, 7 December 2022 at 01:46:21 UTC, Siarhei Siamashka wrote:

import std;

char *sqlite3_column_text() @system {
    return cast(char *)"the sun is shining".ptr;
}

void main() {
    printf("%s\n",sqlite3_column_text());
    writeln(sqlite3_column_text());
    writefln("%s",sqlite3_column_text());
    writefln(std.conv.to!string(sqlite3_column_text()));
}

    char[] s1 = fromStringz(sqlite3_column_text());

    writeln(s1); // everything is fine

    char[] s2 = fromStringz(sqlite3_column_text()); // some other sqlite3 API call

    writeln(s1); // oops, sqlite3 may have already messed up s1

@safe:
import std;

char *sqlite3_column_text() @system {
    return cast(char *)"the sun is shining".ptr;
}

string trusted_sqlite3_column_text() @trusted {
    return std.conv.to!string(sqlite3_column_text());
}

void main() {
    printf("%s\n",sqlite3_column_text());                // Nay!
    writeln(sqlite3_column_text());                      // Nay!
    writefln("%s",sqlite3_column_text());                // Nay!
    writefln(std.conv.to!string(sqlite3_column_text())); // Nay!
    writeln(trusted_sqlite3_column_text());              // Yay!
}

That's a good point, but there also no error checking for the sqlite return, but that's not the point, std.conv.to!string doesn't teach about the difference between c string and d string, it hides the magic

Doing it manually teaches it, that was the point

On Tuesday, 6 December 2022 at 23:41:09 UTC, H. S. Teoh wrote:

Well, if we think the other way around, in the example below we'd copy string, right?

void stringCopy(Chars)(string source,
                    ref Chars target)
{
  import std.algorithm : min;
  auto len = min(target.length - 1,
                 source.length);
  target[0 .. len] = source[0 .. len];
  target[len] = '\0';
}

import std.stdio;
void main()
{ //              |----- 21 chars ------| |-- 8 --|
  string sample = "bu bir deneme olmakta\0gizlimi?";
  char[30] cTxt; // 29 + 1'\0'

  sample.stringCopy = cTxt;  // disappeared ? char
  cTxt.writeln;              // appeared 28 chars

  printf("%s\n", cTxt.ptr);  // appeared 21 chars
  printf("%s\n", &cTxt[22]); // appeared 7 chars
  writefln!"%(%02X %)"(cast(ubyte[])cTxt);
}

Attention, the method used is again a slicing...

SDB@79

On Tuesday, 6 December 2022 at 23:41:09 UTC, H. S. Teoh wrote:

Well, if we think the other way around, in the example below we'd copy string, right?

void stringCopy(Chars)(string source,
                    ref Chars target)
{
  import std.algorithm : min;
  auto len = min(target.length - 1,
                 source.length);
  target[0 .. len] = source[0 .. len];
  target[len] = '\0';
}

import std.stdio;
void main()
{ //              |----- 21 chars ------| |-- 8 --|
  string sample = "bu bir deneme olmakta\0gizlimi?";
  char[30] cTxt; // 29 + 1'\0'

  sample.stringCopy = cTxt;  // disappeared ? char
  cTxt.writeln;              // appeared 28 chars

  printf("%s\n", cTxt.ptr);  // appeared 21 chars
  printf("%s\n", &cTxt[22]); // appeared 7 chars
  writefln!"%(%02X %)"(cast(ubyte[])cTxt);
}

Attention, the method used is again a slicing...

SDB@79