SQLite4  Check-in [22365cae27]

#ifdef LSM_LOG_WORK
      lsmLogMessage(pDb, 0, "finish checkpoint %d", 
          (int)lsmCheckpointId(pDb->aSnapshot, 0)
      );
#endif
    }

    if( rc==LSM_OK && bTruncate ){
      rc = lsmFsTruncateDb(pDb->pFS, (i64)nBlock*lsmFsBlockSize(pDb->pFS));
    }
  }

  lsmShmLock(pDb, LSM_LOCK_CHECKPOINTER, LSM_LOCK_UNLOCK, 0);
  if( pnWrite && rc==LSM_OK ) *pnWrite = nWrite;
  return rc;

    ** character. Two bytes are required in the output buffer for the
    ** nul-terminator.  */
    if( n<0 ){
      u8 *z = (u8*)p;
      while( z[0] || z[1] ) z += 2;
      n = z - (u8*)p;
    }
    nReq = n * 2 + 1;
  }else{
    /* When converting from UTF-16, the maximum growth results from
    ** translating a 2-byte character to a 4-byte UTF-8 character.
    ** A single byte is required for the output string
    ** nul-terminator.  */
    if( n<0 ) n = sqlite4Strlen30(p);
    nReq = n * 2 + 1;

#
# do_test capi2-6.2 {
#   list [sqlite4_step $VM1] \
#        [sqlite4_column_count $VM1] \
#        [get_row_values $VM1] \
#        [get_column_names $VM1]
# } {SQLITE4_BUSY 0 {} {}}



do_test capi2-6.3 {
  execsql {COMMIT} db2
} {}
do_test capi2-6.4 {
  list [sqlite4_step $VM1] \
       [sqlite4_column_count $VM1] \
       [get_row_values $VM1] \
       [get_column_names $VM1]
} {SQLITE4_ROW 1 1 {x counter}}
do_test capi2-6.5 {
  catchsql {INSERT INTO t3 VALUES(10);} db2
} {0 {}}
do_test capi2-6.6 {
  list [sqlite4_step $VM1] \
       [sqlite4_column_count $VM1] \
       [get_row_values $VM1] \
       [get_column_names $VM1]
} {SQLITE4_ROW 1 2 {x counter}}
do_test capi2-6.7 {

    PRAGMA count_changes=on
  }
} {0}
do_test capi2-7.3 {
  stepsql $DB {
    UPDATE t1 SET a=a+10;
  }
} {0 1}
do_test capi2-7.4 {
  stepsql $DB {
    INSERT INTO t1 SELECT a+1,b+1,c+1 FROM t1;
  }
} {0 1}
do_test capi2-7.4b {sqlite4_changes $DB} {1}
do_test capi2-7.5 {
  stepsql $DB {
    UPDATE t1 SET a=a+10;
  }
} {0 2}
do_test capi2-7.5b {sqlite4_changes $DB} {2}
do_test capi2-7.6 {
  stepsql $DB {
    SELECT * FROM t1;
  }
} {0 21 2 3 22 3 4}
do_test capi2-7.7 {
  stepsql $DB {
    INSERT INTO t1 SELECT a+2,b+2,c+2 FROM t1;
  }
} {0 2}
do_test capi2-7.8 {
  sqlite4_changes $DB
} {2}
do_test capi2-7.9 {
  stepsql $DB {
    SELECT * FROM t1;
  }
} {0 21 2 3 22 3 4 23 4 5 24 5 6}
do_test capi2-7.10 {
  stepsql $DB {
    UPDATE t1 SET a=a-20;
    SELECT * FROM t1;
  }
} {0 4 1 2 3 2 3 4 3 4 5 4 5 6}

# Update for version 3: A SELECT statement no longer resets the change
# counter (Test result changes from 0 to 4).
do_test capi2-7.11 {
  sqlite4_changes $DB
} {4}
do_test capi2-7.11a {

# capi3-5.*: Test the various sqlite4_result_* APIs
# capi3-6.*: Test that sqlite4_close fails if there are outstanding VMs.
#

set DB [sqlite4_connection_pointer db]

do_test capi3-1.0 {
  sqlite4_get_autocommit $DB
} 1
do_test capi3-1.1 {
  set STMT [sqlite4_prepare $DB {SELECT name FROM sqlite_master} -1 TAIL]
  sqlite4_finalize $STMT
  set TAIL
} {}
do_test capi3-1.2.1 {
  sqlite4_errcode $DB
} {SQLITE4_OK}
do_test capi3-1.2.2 {
  sqlite4_extended_errcode $DB
} {SQLITE4_OK}
do_test capi3-1.3 {
  sqlite4_errmsg $DB
} {not an error}
do_test capi3-1.4 {
  set sql {SELECT name FROM sqlite_master;SELECT 10}
  set STMT [sqlite4_prepare $DB $sql -1 TAIL]

    set STMT [sqlite4_prepare $DB $sql -1 TAIL]
  }
} {1}
do_test capi3-1.8.1 {
  sqlite4_errcode $DB
} {SQLITE4_ERROR}
do_test capi3-1.8.2 {
  sqlite4_extended_errcode $DB
} {SQLITE4_ERROR}
do_test capi3-1.9 {
  sqlite4_errmsg $DB
} {no such column: namex}

ifcapable {utf16} {
  do_test capi3-2.1 {
    set sql16 [utf16 {SELECT name FROM sqlite_master}]
    set STMT [sqlite4_prepare16 $DB $sql16 -1 ::TAIL]
    sqlite4_finalize $STMT
    utf8 $::TAIL
  } {}
  do_test capi3-2.2 {
    set sql [utf16 {SELECT name FROM sqlite_master;SELECT 10}]
    set STMT [sqlite4_prepare16 $DB $sql -1 TAIL]
    sqlite4_finalize $STMT
    utf8 $TAIL
  } {SELECT 10}
  do_test capi3-2.3 {
    set sql [utf16 {SELECT namex FROM sqlite_master}]
    catch {
      set STMT [sqlite4_prepare16 $DB $sql -1]
    }
  } {1}
  do_test capi3-2.4.1 {
    sqlite4_errcode $DB
  } {SQLITE4_ERROR}
  do_test capi3-2.4.2 {
    sqlite4_extended_errcode $DB
  } {SQLITE4_ERROR}
  do_test capi3-2.5 {
    sqlite4_errmsg $DB
  } {no such column: namex}

  ifcapable schema_pragmas {
    do_test capi3-2.6 {
      execsql {CREATE TABLE tablename(x)}
      set sql16 [utf16 {PRAGMA table_info("TableName"); --excess text}]
      set STMT [sqlite4_prepare16 $DB $sql16 -1]
      sqlite4_step $STMT
    } SQLITE4_ROW
    do_test capi3-2.7 {
      sqlite4_step $STMT
    } SQLITE4_DONE
    do_test capi3-2.8 {
      sqlite4_finalize $STMT
    } SQLITE4_OK
  }

} ;# endif utf16

# rename sqlite4_open sqlite4_open_old
# proc sqlite4_open {fname options} {sqlite4_open_new $fname $options}

do_test capi3-3.1 {
  set db2 [sqlite4_open test.db {}]
  sqlite4_errcode $db2
} {SQLITE4_OK}
# FIX ME: Should test the db handle works.
do_test capi3-3.2 {
  sqlite4_close $db2
} {SQLITE4_OK}
do_test capi3-3.3 {
  catch {
    set db2 [sqlite4_open /bogus/path/test.db {}]
  }
  sqlite4_extended_errcode $db2
} {SQLITE4_CANTOPEN}
do_test capi3-3.4 {
  sqlite4_errmsg $db2
} {unable to open database file}
do_test capi3-3.5 {
  sqlite4_close $db2
} {SQLITE4_OK}
do_test capi3-3.6.1-misuse {
  sqlite4_close $db2
} {SQLITE4_MISUSE}
do_test capi3-3.6.2-misuse {
  sqlite4_errmsg $db2
} {library routine called out of sequence}
ifcapable {utf16} {
  do_test capi3-3.6.3-misuse {
    utf8 [sqlite4_errmsg16 $db2]
  } {library routine called out of sequence}
}

do_test capi3-3.7 {
  set db2 [sqlite4_open]
  sqlite4_errcode $db2
} {SQLITE4_OK}
do_test capi3-3.8 {
  sqlite4_close $db2
} {SQLITE4_OK}

# rename sqlite4_open ""
# rename sqlite4_open_old sqlite4_open

ifcapable {utf16} {
do_test capi3-4.1 {
  set db2 [sqlite4_open16 [utf16 test.db] {}]
  sqlite4_errcode $db2
} {SQLITE4_OK}
# FIX ME: Should test the db handle works.
do_test capi3-4.2 {
  sqlite4_close $db2
} {SQLITE4_OK}
do_test capi3-4.3 {
  catch {
    set db2 [sqlite4_open16 [utf16 /bogus/path/test.db] {}]
  }
  sqlite4_errcode $db2
} {SQLITE4_CANTOPEN}
do_test capi3-4.4 {
  utf8 [sqlite4_errmsg16 $db2]
} {unable to open database file}
do_test capi3-4.5 {
  sqlite4_close $db2
} {SQLITE4_OK}
} ;# utf16

# This proc is used to test the following API calls:
#
# sqlite4_column_count
# sqlite4_column_name
# sqlite4_column_name16
# sqlite4_column_decltype
# sqlite4_column_decltype16

  # Column names in UTF-8
  do_test $test.1 {
    set cnamelist [list]
    foreach i $idxlist {lappend cnamelist [sqlite4_column_name $STMT $i]} 
    set cnamelist
  } $names

  # Column names in UTF-16
  ifcapable {utf16} {
    do_test $test.2 {
      set cnamelist [list]
      foreach i $idxlist {
        lappend cnamelist [utf8 [sqlite4_column_name16 $STMT $i]]
      }
      set cnamelist
    } $names
  }

  # Column names in UTF-8
  do_test $test.3 {
    set cnamelist [list]
    foreach i $idxlist {lappend cnamelist [sqlite4_column_name $STMT $i]} 
    set cnamelist
  } $names

  # Column names in UTF-16
  ifcapable {utf16} {
    do_test $test.4 {
      set cnamelist [list]
      foreach i $idxlist {
        lappend cnamelist [utf8 [sqlite4_column_name16 $STMT $i]]
      }
      set cnamelist
    } $names
  }

  # Column names in UTF-8
  do_test $test.5 {
    set cnamelist [list]
    foreach i $idxlist {lappend cnamelist [sqlite4_column_decltype $STMT $i]} 
    set cnamelist
  } $decltypes

  # Column declaration types in UTF-16
  ifcapable {utf16} {
    do_test $test.6 {
      set cnamelist [list]
      foreach i $idxlist {
        lappend cnamelist [utf8 [sqlite4_column_decltype16 $STMT $i]]
      }
      set cnamelist
    } $decltypes
  }


  # Test some out of range conditions:
  ifcapable {utf16} {
    do_test $test.7 {
      list \
        [sqlite4_column_name $STMT -1] \
        [sqlite4_column_name16 $STMT -1] \
        [sqlite4_column_decltype $STMT -1] \
        [sqlite4_column_decltype16 $STMT -1] \
        [sqlite4_column_name $STMT $numcols] \
        [sqlite4_column_name16 $STMT $numcols] \
        [sqlite4_column_decltype $STMT $numcols] \
        [sqlite4_column_decltype16 $STMT $numcols]
    } {{} {} {} {} {} {} {} {}}
  }
} 

# This proc is used to test the following API calls:
#
# sqlite4_column_origin_name
# sqlite4_column_origin_name16

# Integers
do_test $test.2 {
  set ints [list]
  foreach i $idxlist {lappend ints [sqlite4_column_int64 $STMT $i]}
  set ints
} $ints

# bytes
set lens [list]
foreach i $::idxlist {
  lappend lens [string length [lindex $strings $i]]
}
do_test $test.3 {
  set bytes [list]
  set lens [list]
  foreach i $idxlist {
    lappend bytes [sqlite4_column_bytes $STMT $i]
  }
  set bytes
} $lens

# bytes16
ifcapable {utf16} {
  set lens [list]
  foreach i $::idxlist {
    lappend lens [expr 2 * [string length [lindex $strings $i]]]
  }
  do_test $test.4 {
    set bytes [list]
    set lens [list]
    foreach i $idxlist {
      lappend bytes [sqlite4_column_bytes16 $STMT $i]
    }
    set bytes
  } $lens
}

# Blob
do_test $test.5 {
  set utf8 [list]
  foreach i $idxlist {lappend utf8 [sqlite4_column_blob $STMT $i]}
  set utf8
} $strings

  set utf8 [list]
  foreach i $idxlist {lappend utf8 [sqlite4_column_double $STMT $i]}
  set utf8
} $doubles

# UTF-16
ifcapable {utf16} {

  do_test $test.8 {
    set utf8 [list]
    foreach i $idxlist {lappend utf8 [utf8 [sqlite4_column_text16 $STMT $i]]}
    set utf8
  } $strings
}

    BEGIN;
    CREATE TABLE t1(a, b);
    INSERT INTO t1 VALUES(1, 'int');
    INSERT INTO t1 VALUES(2, 'notatype');
  }
} {}
do_test capi3-11.1.1 {
  sqlite4_get_autocommit $DB
} 0
do_test capi3-11.2 {
  set STMT [sqlite4_prepare $DB "SELECT func(b, a) FROM t1" -1 TAIL]
  sqlite4_step $STMT
} {SQLITE4_ROW}

# As of 3.6.5 a COMMIT is OK during while a query is still running -
# as long as it is a read-only query and not an incremental BLOB write.
#
do_test capi3-11.3.1 {
  catchsql {
    COMMIT;
  }
} {0 {}}
do_test capi3-11.3.2 {
  sqlite4_extended_errcode $DB
} {SQLITE4_OK}
do_test capi3-11.3.3 {
  sqlite4_get_autocommit $DB
} 1
do_test capi3-11.3.4 {
  db eval {PRAGMA lock_status}
} {main shared temp closed}

do_test capi3-11.4 {
  sqlite4_step $STMT
} {SQLITE4_ERROR}
do_test capi3-11.5 {
  sqlite4_finalize $STMT
} {SQLITE4_ERROR}
do_test capi3-11.6 {
  catchsql {
    SELECT * FROM t1;
  }
} {0 {1 int 2 notatype}}
do_test capi3-11.7 {
  sqlite4_get_autocommit $DB
} 1
do_test capi3-11.8 {
  execsql {
    CREATE TABLE t2(a);
    INSERT INTO t2 VALUES(1);
    INSERT INTO t2 VALUES(2);
    BEGIN;
    INSERT INTO t2 VALUES(3);
  }
} {}
do_test capi3-11.8.1 {
  sqlite4_get_autocommit $DB
} 0
do_test capi3-11.9 {
  set STMT [sqlite4_prepare $DB "SELECT a FROM t2" -1 TAIL]
  sqlite4_step $STMT
} {SQLITE4_ROW}
do_test capi3-11.9.1 {
  sqlite4_get_autocommit $DB
} 0
do_test capi3-11.9.2 {
  catchsql {
    ROLLBACK;
  }
} {1 {cannot rollback transaction - SQL statements in progress}}
do_test capi3-11.9.3 {
  sqlite4_get_autocommit $DB
} 0
do_test capi3-11.10 {
  sqlite4_step $STMT
} {SQLITE4_ROW}
do_test capi3-11.11 {
  sqlite4_step $STMT
} {SQLITE4_ROW}
do_test capi3-11.12 {
  sqlite4_step $STMT
} {SQLITE4_DONE}
do_test capi3-11.13 {
  sqlite4_finalize $STMT
} {SQLITE4_OK}
do_test capi3-11.14 {
  execsql {
    SELECT a FROM t2;
  }
} {1 2 3}
do_test capi3-11.14.1 {
  sqlite4_get_autocommit $DB
} 0
do_test capi3-11.15 {
  catchsql {
    ROLLBACK;
  }
} {0 {}}
do_test capi3-11.15.1 {
  sqlite4_get_autocommit $DB
} 1
do_test capi3-11.16 {
  execsql {
    SELECT a FROM t2;
  }
} {1 2}

# Sanity check on the definition of 'outstanding VM'. This means any VM

# Make sure this works correctly and does not reference memory out of
# range.
#
do_test capi3-19.1 {
  sqlite4_prepare_tkt3134 db
} {}

# Tests of the interface when no VFS is registered.
#
if {![info exists tester_do_binarylog]} {
  db close
  vfs_unregister_all
  do_test capi3-20.1 {
    sqlite4_sleep 100
  } {0}
  vfs_reregister_all
}

finish_test

} {db}
do_test 1.2 {
  db write 1 one
  db write 2 two
  db close
} {}
do_test 1.3 {
  expr [file size test.db] < (64*1024)
} 1

#-------------------------------------------------------------------------
# Test that if an attempt is made to open a read-write connection to a 
# non-live database that the client does not have permission to write to is
# attempted an error is reported. In order to open a read-write connection 
# to a database, the client requires:

  attach.test attach3.test attach4.test
  autoindex1.test
  badutf.test badutf2.test
  between.test
  bigrow.test
  bind.test
  blob.test

  boundary1.test boundary2.test boundary3.test boundary4.test

  cast.test
  coalesce.test 
  collate1.test collate2.test collate3.test collate4.test collate5.test
  collate6.test collate7.test collate8.test collate9.test collateA.test
  conflict.test 
  count.test
  cse.test

  rc = sqlite4_prepare(db, zSql, bytes, &pStmt, objc>=5 ? &nUsed : 0);
  Tcl_ResetResult(interp);
  if( sqlite4TestErrCode(interp, db, rc) ) return TCL_ERROR;
  if( objc>=5 ){
    const char *zTail = &zSql[nUsed];
    int nTail = -1;
    if( bytes>=0 ){
      nTail = bytes - nUsed;

    }
    Tcl_ObjSetVar2(interp, objv[4], 0, Tcl_NewStringObj(zTail, nTail), 0);
  }
  if( rc!=SQLITE4_OK ){
    assert( pStmt==0 );
    sprintf(zBuf, "(%d) ", rc);
    Tcl_AppendResult(interp, zBuf, sqlite4_errmsg(db), 0);

      Tcl_AppendResult(interp, " ", aOpt[i].zOptName);
    }
    return TCL_ERROR;
  }
  sqlite4_test_control(SQLITE4_TESTCTRL_OPTIMIZATIONS, db, mask);
  return TCL_OK;
}













































void sqlite4TestInit(Tcl_Interp *interp){
  Sqlitetest_auth_init(interp);
  Sqlitetest_num_init(interp);
  Sqlitetest_func_Init(interp);
}

     { "sqlite4_column_decltype",test_stmt_utf8,(void*)sqlite4_column_decltype},
#endif
#ifdef SQLITE4_ENABLE_COLUMN_METADATA
{ "sqlite4_column_database_name",test_stmt_utf8,(void*)sqlite4_column_database_name},
{ "sqlite4_column_table_name",test_stmt_utf8,(void*)sqlite4_column_table_name},
{ "sqlite4_column_origin_name",test_stmt_utf8,(void*)sqlite4_column_origin_name},
#endif





     { "sqlite4_create_collation",   test_create_collation, 0 },
     { "sqlite4_collation_needed",   test_collation_needed, 0 },
     { "sqlite4_profile",            test_profile, 0 },
     { "sqlite4_trace",              test_trace, 0 },
     { "working_64bit_int",          working_64bit_int,   0   },
     { "sqlite4_create_function_v2", test_create_function_v2, 0 },