mirrors/limbo
1
0
Fork 0
mirror of https://github.com/tursodatabase/limbo.git synced 2025-08-04 18:18:03 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 13

Revert "Merge 'Add support for sqlite_version() scalar function' from Kim Seon Woo"

Browse source 
This reverts commit e365c12ce0, reversing
changes made to 21bd1a961e. The pull request broke some tests:

```
thread 'main' panicked at core/vdbe/mod.rs:1713:72:
index out of bounds: the len is 3 but the index is 3
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
    while executing
"exec {*}$command"
    (procedure "evaluate_sql" line 3)
    invoked from within
"evaluate_sql $sqlite_exec $sql"
    (procedure "run_test" line 2)
    invoked from within
"run_test $::sqlite_exec $combined_sql $combined_expected_output"
    (procedure "do_execsql_test" line 5)
    invoked from within
"do_execsql_test sqlite_version {
  SELECT sqlite_version();
} {3.46.1}"
    (file "./testing/scalar-functions.test" line 434)
    invoked from within
"source $testdir/scalar-functions.test"
    (file "./testing/all.test" line 16)
make: *** [Makefile:59: test-compat] Error 1
```
This commit is contained in:
Pekka Enberg 2024-09-16 14:28:18 +03:00
parent e365c12ce0
commit 9bbfdab5fa
8 changed files with 12 additions and 72 deletions
Download patch file Download diff file Expand all files Collapse all files

2
COMPAT.md
View file

@ -103,7 +103,7 @@ This document describes the SQLite compatibility status of Limbo:
| sqlite_compileoption_used(X) | No | |
| sqlite_offset(X) | No | |
| sqlite_source_id() | No | |
| sqlite_version() | Yes | |
| sqlite_version() | No | |
| substr(X,Y,Z) | Yes | |
| substr(X,Y) | Yes | |
| substring(X,Y,Z) | Yes | |

3
core/function.rs
View file

@ -65,7 +65,6 @@ pub enum ScalarFunc {
Time,
Unicode,
Quote,
SqliteVersion,
UnixEpoch,
}
@ -97,7 +96,6 @@ impl ToString for ScalarFunc {
ScalarFunc::Time => "time".to_string(),
ScalarFunc::Unicode => "unicode".to_string(),
ScalarFunc::Quote => "quote".to_string(),
ScalarFunc::SqliteVersion => "sqlite_version".to_string(),
ScalarFunc::UnixEpoch => "unixepoch".to_string(),
}
}
@ -162,7 +160,6 @@ impl Func {
"time" => Ok(Func::Scalar(ScalarFunc::Time)),
"unicode" => Ok(Func::Scalar(ScalarFunc::Unicode)),
"quote" => Ok(Func::Scalar(ScalarFunc::Quote)),
"sqlite_version" => Ok(Func::Scalar(ScalarFunc::SqliteVersion)),
"json" => Ok(Func::Json(JsonFunc::JSON)),
"unixepoch" => Ok(Func::Scalar(ScalarFunc::UnixEpoch)),
_ => Err(()),

8
core/lib.rs
View file

@ -19,7 +19,7 @@ use log::trace;
use schema::Schema;
use sqlite3_parser::ast;
use sqlite3_parser::{ast::Cmd, lexer::sql::Parser};
use std::sync::{Arc, OnceLock};
use std::sync::Arc;
use std::{cell::RefCell, rc::Rc};
#[cfg(feature = "fs")]
use storage::database::FileStorage;
@ -42,8 +42,6 @@ pub use storage::pager::Page;
pub use storage::wal::Wal;
pub use types::Value;
pub static DATABASE_VERSION: OnceLock<String> = OnceLock::new();
pub struct Database {
pager: Rc<Pager>,
schema: Rc<Schema>,
@ -66,10 +64,6 @@ impl Database {
wal: Rc<dyn Wal>,
) -> Result<Database> {
let db_header = Pager::begin_open(page_io.clone())?;
DATABASE_VERSION.get_or_init(|| {
let version = db_header.borrow().version_number.clone();
version.to_string()
});
io.run_once()?;
let pager = Rc::new(Pager::finish_open(
db_header.clone(),

2
core/storage/sqlite3_ondisk.rs
View file

@ -84,7 +84,7 @@ pub struct DatabaseHeader {
application_id: u32,
reserved: [u8; 20],
version_valid_for: u32,
pub version_number: u32,
version_number: u32,
}
#[derive(Debug, Default)]

20
core/translate/expr.rs
View file

@ -1314,26 +1314,6 @@ pub fn translate_expr(
Ok(target_register)
}
ScalarFunc::SqliteVersion => {
if args.is_some() {
crate::bail_parse_error!("sqlite_version function with arguments");
}
let output_register = program.alloc_register();
program.emit_insn(Insn::Function {
constant_mask: 0,
start_reg: output_register,
dest: output_register,
func: func_ctx,
});
program.emit_insn(Insn::Copy {
src_reg: output_register,
dst_reg: target_register,
amount: 1,
});
Ok(target_register)
}
}
}
}

18
core/vdbe/explain.rs
View file

@ -631,18 +631,12 @@ pub fn insn_to_str(
*dest as i32,
OwnedValue::Text(Rc::new(func.func.to_string())),
0,
if func.arg_count == 0 {
format!("r[{}]=func()", dest)
} else if *start_reg == *start_reg + func.arg_count - 1 {
format!("r[{}]=func(r[{}])", dest, start_reg)
} else {
format!(
"r[{}]=func(r[{}..{}])",
dest,
start_reg,
start_reg + func.arg_count - 1
)
},
format!(
"r[{}]=func(r[{}..{}])",
dest,
start_reg,
start_reg + func.arg_count - 1
),
),
Insn::InitCoroutine {
yield_reg,

27
core/vdbe/mod.rs
View file

@ -31,7 +31,7 @@ use crate::schema::Table;
use crate::storage::sqlite3_ondisk::DatabaseHeader;
use crate::storage::{btree::BTreeCursor, pager::Pager};
use crate::types::{AggContext, Cursor, CursorResult, OwnedRecord, OwnedValue, Record};
use crate::{Result, DATABASE_VERSION};
use crate::Result;
use datetime::{exec_date, exec_time, exec_unixepoch};
@ -1574,12 +1574,6 @@ impl Program {
}
}
}
ScalarFunc::SqliteVersion => {
let version_integer: i64 =
DATABASE_VERSION.get().unwrap().parse()?;
let version = execute_sqlite_version(version_integer);
state.registers[*dest] = OwnedValue::Text(Rc::new(version));
}
},
crate::function::Func::Agg(_) => {
unreachable!("Aggregate functions should not be handled here")
@ -2159,21 +2153,13 @@ fn exec_if(reg: &OwnedValue, null_reg: &OwnedValue, not: bool) -> bool {
}
}
fn execute_sqlite_version(version_integer: i64) -> String {
let major = version_integer / 1_000_000;
let minor = (version_integer % 1_000_000) / 1_000;
let release = version_integer % 1_000;
format!("{}.{}.{}", major, minor, release)
}
#[cfg(test)]
mod tests {
use super::{
exec_abs, exec_char, exec_if, exec_length, exec_like, exec_lower, exec_ltrim, exec_minmax,
exec_nullif, exec_quote, exec_random, exec_round, exec_rtrim, exec_sign, exec_substring,
exec_trim, exec_unicode, exec_upper, execute_sqlite_version, get_new_rowid, Cursor,
CursorResult, LimboError, OwnedRecord, OwnedValue, Result,
exec_trim, exec_unicode, exec_upper, get_new_rowid, Cursor, CursorResult, LimboError,
OwnedRecord, OwnedValue, Result,
};
use mockall::{mock, predicate};
use rand::{rngs::mock::StepRng, thread_rng};
@ -2768,11 +2754,4 @@ mod tests {
let expected = Some(OwnedValue::Null);
assert_eq!(exec_sign(&input), expected);
}
#[test]
fn test_execute_sqlite_version() {
let version_integer = 3046001;
let expected = "3.46.1";
assert_eq!(execute_sqlite_version(version_integer), expected);
}
}

4
testing/scalar-functions.test
View file

@ -430,7 +430,3 @@ do_execsql_test sign-text-non-numeric {
do_execsql_test sign-null {
SELECT sign(NULL);
} {}
do_execsql_test sqlite_version {
SELECT sqlite_version();
} {3.46.1}