SQLite Forum

There seems to be a limit to the use of bounded variables mixed with string concatenation operator. 
With "myvar" set to B:

>SELECT 'A' \|\| :myvar \|\| 'C'

returns 'AB'

whereas this:

>SELECT printf("A%sC",:myvar)

correctly returns ABC

I couldn't find anywhere in the doc an explanation for this limitation. I'm using sqlite shipped with iOS (14), called from swift 5.3.  



Full code (using swift, to be used in a XCTest) : 

```swift
func testSqliteConcat() {
        var db: OpaquePointer?
        guard sqlite3_open(dbUrl.path, &db) == SQLITE_OK else {
            return XCTFail()
        }
        var statement: OpaquePointer?
        /* */
        XCTAssertEqual(
            sqlite3_prepare_v2(db, """
                    SELECT 'A' || :myvar || 'C'
                """, -1, &statement, nil
            ),

            SQLITE_OK
        )

        /* query that works
         XCTAssertEqual(
             sqlite3_prepare_v2(db, """
                     SELECT printf("A%sC",:myvar)
                 """, -1, &statement, nil
             ),

             SQLITE_OK
         )
         */
        XCTAssertEqual("B".utf8CString.withUnsafeBufferPointer { (buffer) -> Int32 in
            return sqlite3_bind_text(
                statement,
                1,
                buffer.baseAddress,
                Int32(buffer.count),
                unsafeBitCast(-1, to: sqlite3_destructor_type.self)
            )
        }, SQLITE_OK)

        while sqlite3_step(statement) == SQLITE_ROW {
        guard let cString = sqlite3_column_text(statement, 0) else {
            XCTFail("no column result")
            return
        }
            print("result: ", String(cString:cString))
        }
    }
```