aljaz/turso
1
0
Fork 0
mirror of https://github.com/aljazceru/turso.git synced 2025-12-31 23:14:21 +01:00
Code Issues Packages Projects Releases Wiki Activity

bind/java: Rename to Turso

Browse Source
This commit is contained in:
Diego Reis
2025-07-03 02:25:23 -03:00
parent 3bd5d4c732
commit 4b32577f80
48 changed files with 455 additions and 409 deletions
Download Patch File Download Diff File Expand all files Collapse all files

13
bindings/java/src/main/java/tech/turso/JDBC.java
View File

@@ -5,15 +5,16 @@ import java.util.Locale;
import java.util.Properties;
import tech.turso.annotations.Nullable;
import tech.turso.annotations.SkipNullableCheck;
import tech.turso.core.LimboPropertiesHolder;
import tech.turso.core.TursoPropertiesHolder;
import tech.turso.jdbc4.JDBC4Connection;
import tech.turso.utils.Logger;
import tech.turso.utils.LoggerFactory;
public final class JDBC implements Driver {
private static final Logger logger = LoggerFactory.getLogger(JDBC.class);
private static final String VALID_URL_PREFIX = "jdbc:sqlite:";
private static final String VALID_URL_PREFIX = "jdbc:turso:";
static {
try {
@@ -33,7 +34,7 @@ public final class JDBC implements Driver {
}
private static boolean isValidURL(String url) {
return url != null && url.toLowerCase(Locale.ROOT).startsWith(VALID_URL_PREFIX);
return (url != null && url.toLowerCase(Locale.ROOT).startsWith(VALID_URL_PREFIX));
}
private static String extractAddress(String url) {
@@ -53,17 +54,17 @@ public final class JDBC implements Driver {
@Override
public DriverPropertyInfo[] getPropertyInfo(String url, Properties info) throws SQLException {
return LimboConfig.getDriverPropertyInfo();
return TursoConfig.getDriverPropertyInfo();
}
@Override
public int getMajorVersion() {
return Integer.parseInt(LimboPropertiesHolder.getDriverVersion().split("\\.")[0]);
return Integer.parseInt(TursoPropertiesHolder.getDriverVersion().split("\\.")[0]);
}
@Override
public int getMinorVersion() {
return Integer.parseInt(LimboPropertiesHolder.getDriverVersion().split("\\.")[1]);
return Integer.parseInt(TursoPropertiesHolder.getDriverVersion().split("\\.")[1]);
}
@Override

10
bindings/java/src/main/java/tech/turso/LimboConfig.java → bindings/java/src/main/java/tech/turso/TursoConfig.java
View File

@@ -4,11 +4,12 @@ import java.sql.DriverPropertyInfo;
import java.util.Arrays;
import java.util.Properties;
/** Limbo Configuration. */
public final class LimboConfig {
private final Properties pragma;
/** Turso Configuration. */
public final class TursoConfig {
public LimboConfig(Properties properties) {
private Properties pragma;
public TursoConfig(Properties properties) {
this.pragma = properties;
}
@@ -33,6 +34,7 @@ public final class LimboConfig {
public enum Pragma {
;
private final String pragmaName;
private final String description;
private final String[] choices;

14
bindings/java/src/main/java/tech/turso/LimboDataSource.java → bindings/java/src/main/java/tech/turso/TursoDataSource.java
View File

@@ -10,19 +10,19 @@ import javax.sql.DataSource;
import tech.turso.annotations.Nullable;
import tech.turso.annotations.SkipNullableCheck;
/** Provides {@link DataSource} API for configuring Limbo database connection. */
public final class LimboDataSource implements DataSource {
/** Provides {@link DataSource} API for configuring Turso database connection. */
public final class TursoDataSource implements DataSource {
private final LimboConfig limboConfig;
private final TursoConfig tursoConfig;
private final String url;
/**
* Creates a datasource based on the provided configuration.
*
* @param limboConfig The configuration for the datasource.
* @param tursoConfig The configuration for the datasource.
*/
public LimboDataSource(LimboConfig limboConfig, String url) {
this.limboConfig = limboConfig;
public TursoDataSource(TursoConfig tursoConfig, String url) {
this.tursoConfig = tursoConfig;
this.url = url;
}
@@ -36,7 +36,7 @@ public final class LimboDataSource implements DataSource {
@Nullable
public Connection getConnection(@Nullable String username, @Nullable String password)
throws SQLException {
Properties properties = limboConfig.toProperties();
Properties properties = tursoConfig.toProperties();
if (username != null) properties.put("user", username);
if (password != null) properties.put("pass", password);
return JDBC.createConnection(url, properties);

20
bindings/java/src/main/java/tech/turso/LimboErrorCode.java → bindings/java/src/main/java/tech/turso/TursoErrorCode.java
View File

@@ -2,8 +2,8 @@ package tech.turso;
import tech.turso.core.SqliteCode;
/** Limbo error code. Superset of SQLite3 error code. */
public enum LimboErrorCode {
/** Turso error code. Superset of SQLite3 error code. */
public enum TursoErrorCode {
SQLITE_OK(SqliteCode.SQLITE_OK, "Successful result"),
SQLITE_ERROR(SqliteCode.SQLITE_ERROR, "SQL error or missing database"),
SQLITE_INTERNAL(SqliteCode.SQLITE_INTERNAL, "An internal logic error in SQLite"),
@@ -37,9 +37,9 @@ public enum LimboErrorCode {
SQLITE_NULL(SqliteCode.SQLITE_NULL, "Null type"),
UNKNOWN_ERROR(-1, "Unknown error"),
LIMBO_FAILED_TO_PARSE_BYTE_ARRAY(1100, "Failed to parse ut8 byte array"),
LIMBO_FAILED_TO_PREPARE_STATEMENT(1200, "Failed to prepare statement"),
LIMBO_ETC(9999, "Unclassified error");
TURSO_FAILED_TO_PARSE_BYTE_ARRAY(1100, "Failed to parse ut8 byte array"),
TURSO_FAILED_TO_PREPARE_STATEMENT(1200, "Failed to prepare statement"),
TURSO_ETC(9999, "Unclassified error");
public final int code;
public final String message;
@@ -48,14 +48,14 @@ public enum LimboErrorCode {
* @param code Error code
* @param message Message for the error.
*/
LimboErrorCode(int code, String message) {
TursoErrorCode(int code, String message) {
this.code = code;
this.message = message;
}
public static LimboErrorCode getErrorCode(int errorCode) {
for (LimboErrorCode limboErrorCode : LimboErrorCode.values()) {
if (errorCode == limboErrorCode.code) return limboErrorCode;
public static TursoErrorCode getErrorCode(int errorCode) {
for (TursoErrorCode tursoErrorCode : TursoErrorCode.values()) {
if (errorCode == tursoErrorCode.code) return tursoErrorCode;
}
return UNKNOWN_ERROR;
@@ -63,6 +63,6 @@ public enum LimboErrorCode {
@Override
public String toString() {
return "LimboErrorCode{" + "code=" + code + ", message='" + message + '\'' + '}';
return ("tursoErrorCode{" + "code=" + code + ", message='" + message + '\'' + '}');
}
}

35
bindings/java/src/main/java/tech/turso/core/LimboConnection.java → bindings/java/src/main/java/tech/turso/core/TursoConnection.java
View File

@@ -6,37 +6,38 @@ import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.Properties;
import tech.turso.annotations.NativeInvocation;
import tech.turso.utils.LimboExceptionUtils;
import tech.turso.utils.Logger;
import tech.turso.utils.LoggerFactory;
import tech.turso.utils.TursoExceptionUtils;
public final class LimboConnection {
private static final Logger logger = LoggerFactory.getLogger(LimboConnection.class);
public final class TursoConnection {
private static final Logger logger = LoggerFactory.getLogger(TursoConnection.class);
private final String url;
private final long connectionPtr;
private final LimboDB database;
private final TursoDB database;
private boolean closed;
public LimboConnection(String url, String filePath) throws SQLException {
public TursoConnection(String url, String filePath) throws SQLException {
this(url, filePath, new Properties());
}
/**
* Creates a connection to limbo database
* Creates a connection to turso database
*
* @param url e.g. "jdbc:sqlite:fileName"
* @param url e.g. "jdbc:turso:fileName"
* @param filePath path to file
*/
public LimboConnection(String url, String filePath, Properties properties) throws SQLException {
public TursoConnection(String url, String filePath, Properties properties) throws SQLException {
this.url = url;
this.database = open(url, filePath, properties);
this.connectionPtr = this.database.connect();
}
private static LimboDB open(String url, String filePath, Properties properties)
private static TursoDB open(String url, String filePath, Properties properties)
throws SQLException {
return LimboDBFactory.open(url, filePath, properties);
return TursoDBFactory.open(url, filePath, properties);
}
public void checkOpen() throws SQLException {
@@ -61,7 +62,7 @@ public final class LimboConnection {
return closed;
}
public LimboDB getDatabase() {
public TursoDB getDatabase() {
return database;
}
@@ -72,18 +73,18 @@ public final class LimboConnection {
* @return Pointer to statement.
* @throws SQLException if a database access error occurs.
*/
public LimboStatement prepare(String sql) throws SQLException {
public TursoStatement prepare(String sql) throws SQLException {
logger.trace("DriverManager [{}] [SQLite EXEC] {}", Thread.currentThread().getName(), sql);
byte[] sqlBytes = stringToUtf8ByteArray(sql);
if (sqlBytes == null) {
throw new SQLException("Failed to convert " + sql + " into bytes");
}
return new LimboStatement(sql, prepareUtf8(connectionPtr, sqlBytes));
return new TursoStatement(sql, prepareUtf8(connectionPtr, sqlBytes));
}
private native long prepareUtf8(long connectionPtr, byte[] sqlUtf8) throws SQLException;
// TODO: check whether this is still valid for limbo
// TODO: check whether this is still valid for turso
/**
* Checks whether the type, concurrency, and holdability settings for a {@link ResultSet} are
* supported by the SQLite interface. Supported settings are:
@@ -117,8 +118,8 @@ public final class LimboConnection {
* @param errorCode Error code.
* @param errorMessageBytes Error message.
*/
@NativeInvocation(invokedFrom = "limbo_connection.rs")
private void throwLimboException(int errorCode, byte[] errorMessageBytes) throws SQLException {
LimboExceptionUtils.throwLimboException(errorCode, errorMessageBytes);
@NativeInvocation(invokedFrom = "turso_connection.rs")
private void throwTursoException(int errorCode, byte[] errorMessageBytes) throws SQLException {
TursoExceptionUtils.throwTursoException(errorCode, errorMessageBytes);
}
}

47
bindings/java/src/main/java/tech/turso/core/LimboDB.java → bindings/java/src/main/java/tech/turso/core/TursoDB.java
View File

@@ -7,16 +7,17 @@ import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.sql.SQLException;
import tech.turso.LimboErrorCode;
import tech.turso.TursoErrorCode;
import tech.turso.annotations.NativeInvocation;
import tech.turso.annotations.VisibleForTesting;
import tech.turso.utils.LimboExceptionUtils;
import tech.turso.utils.Logger;
import tech.turso.utils.LoggerFactory;
import tech.turso.utils.TursoExceptionUtils;
/** This class provides a thin JNI layer over the SQLite3 C API. */
public final class LimboDB implements AutoCloseable {
private static final Logger logger = LoggerFactory.getLogger(LimboDB.class);
public final class TursoDB implements AutoCloseable {
private static final Logger logger = LoggerFactory.getLogger(TursoDB.class);
// Pointer to database instance
private long dbPointer;
private boolean isOpen;
@@ -39,10 +40,10 @@ public final class LimboDB implements AutoCloseable {
* extensions.
*/
enum Architecture {
MACOS_ARM64("libs/macos_arm64/lib_limbo_java.dylib", ".dylib"),
MACOS_X86("libs/macos_x86/lib_limbo_java.dylib", ".dylib"),
LINUX_X86("libs/linux_x86/lib_limbo_java.so", ".so"),
WINDOWS("libs/windows/lib_limbo_java.dll", ".dll"),
MACOS_ARM64("libs/macos_arm64/lib_turso_java.dylib", ".dylib"),
MACOS_X86("libs/macos_x86/lib_turso_java.dylib", ".dylib"),
LINUX_X86("libs/linux_x86/lib_turso_java.so", ".so"),
WINDOWS("libs/windows/lib_turso_java.dll", ".dll"),
UNSUPPORTED("", "");
private final String libPath;
@@ -90,7 +91,7 @@ public final class LimboDB implements AutoCloseable {
}
/**
* This method attempts to load the native library required for Limbo operations. It first tries
* This method attempts to load the native library required for turso operations. It first tries
* to load the library from the system's library path using {@link #loadFromSystemPath()}. If that
* fails, it attempts to load the library from the JAR file using {@link #loadFromJar()}. If
* either method succeeds, the `isLoaded` flag is set to true. If both methods fail, an {@link
@@ -115,14 +116,14 @@ public final class LimboDB implements AutoCloseable {
/**
* Load the native library from the system path.
*
* <p>This method attempts to load the native library named "_limbo_java" from the system's
* <p>This method attempts to load the native library named "_turso_java" from the system's
* library path. If the library is successfully loaded, the `isLoaded` flag is set to true.
*
* @return true if the library was successfully loaded, false otherwise.
*/
private static boolean loadFromSystemPath() {
try {
System.loadLibrary("_limbo_java");
System.loadLibrary("_turso_java");
return true;
} catch (Throwable t) {
logger.info("Unable to load from default path: {}", String.valueOf(t));
@@ -148,7 +149,7 @@ public final class LimboDB implements AutoCloseable {
}
try {
InputStream is = LimboDB.class.getClassLoader().getResourceAsStream(arch.getLibPath());
InputStream is = TursoDB.class.getClassLoader().getResourceAsStream(arch.getLibPath());
assert is != null;
File file = convertInputStreamToFile(is, arch);
System.load(file.getPath());
@@ -178,15 +179,15 @@ public final class LimboDB implements AutoCloseable {
}
/**
* @param url e.g. "jdbc:sqlite:fileName
* @param url eTurso.gTursoTurso. "jdbc:turso:fileName
* @param filePath e.g. path to file
*/
public static LimboDB create(String url, String filePath) throws SQLException {
return new LimboDB(url, filePath);
public static TursoDB create(String url, String filePath) throws SQLException {
return new TursoDB(url, filePath);
}
// TODO: receive config as argument
private LimboDB(String url, String filePath) {
private TursoDB(String url, String filePath) {
this.url = url;
this.filePath = filePath;
}
@@ -208,14 +209,14 @@ public final class LimboDB implements AutoCloseable {
private void open0(String filePath, int openFlags) throws SQLException {
if (isOpen) {
throw LimboExceptionUtils.buildLimboException(
LimboErrorCode.LIMBO_ETC.code, "Already opened");
throw TursoExceptionUtils.buildTursoException(
TursoErrorCode.TURSO_ETC.code, "Already opened");
}
byte[] filePathBytes = stringToUtf8ByteArray(filePath);
if (filePathBytes == null) {
throw LimboExceptionUtils.buildLimboException(
LimboErrorCode.LIMBO_ETC.code,
throw TursoExceptionUtils.buildTursoException(
TursoErrorCode.TURSO_ETC.code,
"File path cannot be converted to byteArray. File name: " + filePath);
}
@@ -250,8 +251,8 @@ public final class LimboDB implements AutoCloseable {
* @param errorCode Error code.
* @param errorMessageBytes Error message.
*/
@NativeInvocation(invokedFrom = "limbo_db.rs")
private void throwLimboException(int errorCode, byte[] errorMessageBytes) throws SQLException {
LimboExceptionUtils.throwLimboException(errorCode, errorMessageBytes);
@NativeInvocation(invokedFrom = "turso_db.rs")
private void throwTursoException(int errorCode, byte[] errorMessageBytes) throws SQLException {
TursoExceptionUtils.throwTursoException(errorCode, errorMessageBytes);
}
}

18
bindings/java/src/main/java/tech/turso/core/LimboDBFactory.java → bindings/java/src/main/java/tech/turso/core/TursoDBFactory.java
View File

@@ -5,12 +5,12 @@ import java.util.Properties;
import java.util.concurrent.ConcurrentHashMap;
/**
* Factory class for managing and creating instances of {@link LimboDB}. This class ensures that
* multiple instances of {@link LimboDB} with the same URL are not created.
* Factory class for managing and creating instances of {@link TursoDB}. This class ensures that
* multiple instances of {@link TursoDB} with the same URL are not created.
*/
public final class LimboDBFactory {
public final class TursoDBFactory {
private static final ConcurrentHashMap<String, LimboDB> databaseHolder =
private static final ConcurrentHashMap<String, TursoDB> databaseHolder =
new ConcurrentHashMap<>();
/**
@@ -20,11 +20,11 @@ public final class LimboDBFactory {
* @param url the URL of the database
* @param filePath the path to the database file
* @param properties additional properties for the database connection
* @return an instance of {@link LimboDB}
* @return an instance of {@link tursoDB}
* @throws SQLException if there is an error opening the connection
* @throws IllegalArgumentException if the fileName is empty
*/
public static LimboDB open(String url, String filePath, Properties properties)
public static TursoDB open(String url, String filePath, Properties properties)
throws SQLException {
if (databaseHolder.containsKey(url)) {
return databaseHolder.get(url);
@@ -34,10 +34,10 @@ public final class LimboDBFactory {
throw new IllegalArgumentException("filePath should not be empty");
}
final LimboDB database;
final TursoDB database;
try {
LimboDB.load();
database = LimboDB.create(url, filePath);
TursoDB.load();
database = TursoDB.create(url, filePath);
} catch (Exception e) {
throw new SQLException("Error opening connection", e);
}

17
bindings/java/src/main/java/tech/turso/core/LimboPropertiesHolder.java → bindings/java/src/main/java/tech/turso/core/TursoPropertiesHolder.java
View File

@@ -7,21 +7,24 @@ import tech.turso.jdbc4.JDBC4DatabaseMetaData;
import tech.turso.utils.Logger;
import tech.turso.utils.LoggerFactory;
public class LimboPropertiesHolder {
private static final Logger logger = LoggerFactory.getLogger(LimboPropertiesHolder.class);
public class TursoPropertiesHolder {
private static final Logger logger = LoggerFactory.getLogger(TursoPropertiesHolder.class);
private static String driverName = "";
private static String driverVersion = "";
static {
try (InputStream limboJdbcPropStream =
JDBC4DatabaseMetaData.class.getClassLoader().getResourceAsStream("limbo-jdbc.properties")) {
if (limboJdbcPropStream == null) {
throw new IOException("Cannot load limbo-jdbc.properties from jar");
try (InputStream tursoJdbcPropStream =
JDBC4DatabaseMetaData.class
.getClassLoader()
.getResourceAsStream("turso-jdbc.properties"); ) {
if (tursoJdbcPropStream == null) {
throw new IOException("Cannot load turso-jdbc.properties from jar");
}
final Properties properties = new Properties();
properties.load(limboJdbcPropStream);
properties.load(tursoJdbcPropStream);
driverName = properties.getProperty("driverName");
driverVersion = properties.getProperty("driverVersion");
} catch (IOException e) {

26
bindings/java/src/main/java/tech/turso/core/LimboResultSet.java → bindings/java/src/main/java/tech/turso/core/TursoResultSet.java
View File

@@ -7,17 +7,17 @@ import tech.turso.utils.Logger;
import tech.turso.utils.LoggerFactory;
/**
* A table of data representing limbo database result set, which is generated by executing a
* A table of data representing turso database result set, which is generated by executing a
* statement that queries the database.
*
* <p>A {@link LimboResultSet} object is automatically closed when the {@link LimboStatement} object
* <p>A {@link TursoResultSet} object is automatically closed when the {@link TursoStatement} object
* that generated it is closed or re-executed.
*/
public final class LimboResultSet {
public final class TursoResultSet {
private static final Logger log = LoggerFactory.getLogger(LimboResultSet.class);
private static final Logger log = LoggerFactory.getLogger(TursoResultSet.class);
private final LimboStatement statement;
private final TursoStatement statement;
// Name of the columns
private String[] columnNames = new String[0];
@@ -31,13 +31,13 @@ public final class LimboResultSet {
private int row = 0;
private boolean pastLastRow = false;
@Nullable private LimboStepResult lastStepResult;
@Nullable private TursoStepResult lastStepResult;
public static LimboResultSet of(LimboStatement statement) {
return new LimboResultSet(statement);
public static TursoResultSet of(TursoStatement statement) {
return new TursoResultSet(statement);
}
private LimboResultSet(LimboStatement statement) {
private TursoResultSet(TursoStatement statement) {
this.open = true;
this.statement = statement;
}
@@ -57,13 +57,13 @@ public final class LimboResultSet {
}
/**
* Moves the cursor forward one row from its current position. A {@link LimboResultSet} cursor is
* Moves the cursor forward one row from its current position. A {@link tursoResultSet} cursor is
* initially positioned before the first fow; the first call to the method <code>next</code> makes
* the first row the current row; the second call makes the second row the current row, and so on.
* When a call to the <code>next</code> method returns <code>false</code>, the cursor is
* positioned after the last row.
*
* <p>Note that limbo only supports <code>ResultSet.TYPE_FORWARD_ONLY</code>, which means that the
* <p>Note that turso only supports <code>ResultSet.TYPE_FORWARD_ONLY</code>, which means that the
* cursor can only move forward.
*/
public boolean next() throws SQLException {
@@ -157,7 +157,7 @@ public final class LimboResultSet {
@Override
public String toString() {
return "LimboResultSet{"
return ("tursoResultSet{"
+ "statement="
+ statement
+ ", isEmptyResultSet="
@@ -172,6 +172,6 @@ public final class LimboResultSet {
+ pastLastRow
+ ", lastResult="
+ lastStepResult
+ '}';
+ '}');
}
}

50
bindings/java/src/main/java/tech/turso/core/LimboStatement.java → bindings/java/src/main/java/tech/turso/core/TursoStatement.java
View File

@@ -3,36 +3,37 @@ package tech.turso.core;
import java.sql.SQLException;
import tech.turso.annotations.NativeInvocation;
import tech.turso.annotations.Nullable;
import tech.turso.utils.LimboExceptionUtils;
import tech.turso.utils.Logger;
import tech.turso.utils.LoggerFactory;
import tech.turso.utils.TursoExceptionUtils;
/**
* By default, only one <code>resultSet</code> object per <code>LimboStatement</code> can be open at
* By default, only one <code>resultSet</code> object per <code>TursoStatement</code> can be open at
* the same time. Therefore, if the reading of one <code>resultSet</code> object is interleaved with
* the reading of another, each must have been generated by different <code>LimboStatement</code>
* objects. All execution method in the <code>LimboStatement</code> implicitly close the current
* the reading of another, each must have been generated by different <code>TursoStatement</code>
* objects. All execution method in the <code>TursoStatement</code> implicitly close the current
* <code>resultSet</code> object of the statement if an open one exists.
*/
public final class LimboStatement {
private static final Logger log = LoggerFactory.getLogger(LimboStatement.class);
public final class TursoStatement {
private static final Logger log = LoggerFactory.getLogger(TursoStatement.class);
private final String sql;
private final long statementPointer;
private final LimboResultSet resultSet;
private final TursoResultSet resultSet;
private boolean closed;
// TODO: what if the statement we ran was DDL, update queries and etc. Should we still create a
// resultSet?
public LimboStatement(String sql, long statementPointer) {
public TursoStatement(String sql, long statementPointer) {
this.sql = sql;
this.statementPointer = statementPointer;
this.resultSet = LimboResultSet.of(this);
this.resultSet = TursoResultSet.of(this);
log.debug("Creating statement with sql: {}", this.sql);
}
public LimboResultSet getResultSet() {
public TursoResultSet getResultSet() {
return resultSet;
}
@@ -46,8 +47,8 @@ public final class LimboStatement {
return resultSet.hasLastStepReturnedRow();
}
LimboStepResult step() throws SQLException {
final LimboStepResult result = step(this.statementPointer);
TursoStepResult step() throws SQLException {
final TursoStepResult result = step(this.statementPointer);
if (result == null) {
throw new SQLException("step() returned null, which is only returned when an error occurs");
}
@@ -56,12 +57,12 @@ public final class LimboStatement {
}
/**
* Because Limbo supports async I/O, it is possible to return a {@link LimboStepResult} with
* {@link LimboStepResult#STEP_RESULT_ID_ROW}. However, this is handled by the native side, so you
* can expect that this method will not return a {@link LimboStepResult#STEP_RESULT_ID_ROW}.
* Because turso supports async I/O, it is possible to return a {@link TursoStepResult} with
* {@link TursoStepResult#STEP_RESULT_ID_ROW}. However, this is handled by the native side, so you
* can expect that this method will not return a {@link TursoStepResult#STEP_RESULT_ID_ROW}.
*/
@Nullable
private native LimboStepResult step(long stmtPointer) throws SQLException;
private native TursoStepResult step(long stmtPointer) throws SQLException;
/**
* Throws formatted SQLException with error code and message.
@@ -69,9 +70,9 @@ public final class LimboStatement {
* @param errorCode Error code.
* @param errorMessageBytes Error message.
*/
@NativeInvocation(invokedFrom = "limbo_statement.rs")
private void throwLimboException(int errorCode, byte[] errorMessageBytes) throws SQLException {
LimboExceptionUtils.throwLimboException(errorCode, errorMessageBytes);
@NativeInvocation(invokedFrom = "turso_statement.rs")
private void throwTursoException(int errorCode, byte[] errorMessageBytes) throws SQLException {
TursoExceptionUtils.throwTursoException(errorCode, errorMessageBytes);
}
/**
@@ -90,8 +91,8 @@ public final class LimboStatement {
private native void _close(long statementPointer);
/**
* Initializes the column metadata, such as the names of the columns. Since {@link LimboStatement}
* can only have a single {@link LimboResultSet}, it is appropriate to place the initialization of
* Initializes the column metadata, such as the names of the columns. Since {@link tursoStatement}
* can only have a single {@link tursoResultSet}, it is appropriate to place the initialization of
* column metadata here.
*
* @throws SQLException if a database access error occurs while retrieving column names
@@ -125,7 +126,7 @@ public final class LimboStatement {
/**
* Binds an integer value to the prepared statement at the specified position. This function calls
* bindLong because Limbo treats all integers as long (as well as SQLite).
* bindLong because turso treats all integers as long (as well as SQLite).
*
* <p>According to SQLite documentation, the value is a signed integer, stored in 0, 1, 2, 3, 4,
* 6, or 8 bytes depending on the magnitude of the value.
@@ -229,6 +230,7 @@ public final class LimboStatement {
}
private native long totalChanges(long statementPointer) throws SQLException;
/**
* Checks if the statement is closed.
*
@@ -240,12 +242,12 @@ public final class LimboStatement {
@Override
public String toString() {
return "LimboStatement{"
return ("tursoStatement{"
+ "statementPointer="
+ statementPointer
+ ", sql='"
+ sql
+ '\''
+ '}';
+ '}');
}
}

24
bindings/java/src/main/java/tech/turso/core/LimboStepResult.java → bindings/java/src/main/java/tech/turso/core/TursoStepResult.java
View File

@@ -4,8 +4,9 @@ import java.util.Arrays;
import tech.turso.annotations.NativeInvocation;
import tech.turso.annotations.Nullable;
/** Represents the step result of limbo's statement's step function. */
public final class LimboStepResult {
/** Represents the step result of turso's statement's step function. */
public final class TursoStepResult {
private static final int STEP_RESULT_ID_ROW = 10;
private static final int STEP_RESULT_ID_IO = 20;
private static final int STEP_RESULT_ID_DONE = 30;
@@ -15,18 +16,19 @@ public final class LimboStepResult {
private static final int STEP_RESULT_ID_BUSY = 50;
private static final int STEP_RESULT_ID_ERROR = 60;
// Identifier for limbo's StepResult
// Identifier for Turso's StepResult
private final int stepResultId;
@Nullable private final Object[] result;
@NativeInvocation(invokedFrom = "limbo_statement.rs")
public LimboStepResult(int stepResultId) {
@NativeInvocation(invokedFrom = "turso_statement.rs")
public TursoStepResult(int stepResultId) {
this.stepResultId = stepResultId;
this.result = null;
}
@NativeInvocation(invokedFrom = "limbo_statement.rs")
public LimboStepResult(int stepResultId, Object[] result) {
@NativeInvocation(invokedFrom = "turso_statement.rs")
public TursoStepResult(int stepResultId, Object[] result) {
this.stepResultId = stepResultId;
this.result = result;
}
@@ -41,10 +43,10 @@ public final class LimboStepResult {
public boolean isInInvalidState() {
// current implementation doesn't allow STEP_RESULT_ID_IO to be returned
return stepResultId == STEP_RESULT_ID_IO
return (stepResultId == STEP_RESULT_ID_IO
|| stepResultId == STEP_RESULT_ID_INTERRUPT
|| stepResultId == STEP_RESULT_ID_BUSY
|| stepResultId == STEP_RESULT_ID_ERROR;
|| stepResultId == STEP_RESULT_ID_ERROR);
}
@Nullable
@@ -54,12 +56,12 @@ public final class LimboStepResult {
@Override
public String toString() {
return "LimboStepResult{"
return ("tursoStepResult{"
+ "stepResultName="
+ getStepResultName()
+ ", result="
+ Arrays.toString(result)
+ '}';
+ '}');
}
private String getStepResultName() {

17
bindings/java/src/main/java/tech/turso/exceptions/LimboException.java
View File

@@ -1,17 +0,0 @@
package tech.turso.exceptions;
import java.sql.SQLException;
import tech.turso.LimboErrorCode;
public final class LimboException extends SQLException {
private final LimboErrorCode resultCode;
public LimboException(String message, LimboErrorCode resultCode) {
super(message, null, resultCode.code & 0xff);
this.resultCode = resultCode;
}
public LimboErrorCode getResultCode() {
return resultCode;
}
}

18
bindings/java/src/main/java/tech/turso/exceptions/TursoException.java Normal file
View File

@@ -0,0 +1,18 @@
package tech.turso.exceptions;
import java.sql.SQLException;
import tech.turso.TursoErrorCode;
public final class TursoException extends SQLException {
private TursoErrorCode resultCode;
public TursoException(String message, TursoErrorCode resultCode) {
super(message, null, resultCode.code & 0xff);
this.resultCode = resultCode;
}
public TursoErrorCode getResultCode() {
return resultCode;
}
}

16
bindings/java/src/main/java/tech/turso/jdbc4/JDBC4Connection.java
View File

@@ -6,24 +6,24 @@ import java.util.Map;
import java.util.Properties;
import java.util.concurrent.Executor;
import tech.turso.annotations.SkipNullableCheck;
import tech.turso.core.LimboConnection;
import tech.turso.core.LimboStatement;
import tech.turso.core.TursoConnection;
import tech.turso.core.TursoStatement;
public final class JDBC4Connection implements Connection {
private final LimboConnection connection;
private final TursoConnection connection;
private Map<String, Class<?>> typeMap = new HashMap<>();
public JDBC4Connection(String url, String filePath) throws SQLException {
this.connection = new LimboConnection(url, filePath);
this.connection = new TursoConnection(url, filePath);
}
public JDBC4Connection(String url, String filePath, Properties properties) throws SQLException {
this.connection = new LimboConnection(url, filePath, properties);
this.connection = new TursoConnection(url, filePath, properties);
}
public LimboStatement prepare(String sql) throws SQLException {
public TursoStatement prepare(String sql) throws SQLException {
return connection.prepare(sql);
}
@@ -154,7 +154,7 @@ public final class JDBC4Connection implements Connection {
public void setHoldability(int holdability) throws SQLException {
connection.checkOpen();
if (holdability != ResultSet.CLOSE_CURSORS_AT_COMMIT) {
throw new SQLException("Limbo only supports CLOSE_CURSORS_AT_COMMIT");
throw new SQLException("turso only supports CLOSE_CURSORS_AT_COMMIT");
}
}
@@ -201,7 +201,7 @@ public final class JDBC4Connection implements Connection {
public CallableStatement prepareCall(
String sql, int resultSetType, int resultSetConcurrency, int resultSetHoldability)
throws SQLException {
throw new SQLException("Limbo does not support stored procedures");
throw new SQLException("turso does not support stored procedures");
}
@Override

51
bindings/java/src/main/java/tech/turso/jdbc4/JDBC4DatabaseMetaData.java
View File

@@ -9,7 +9,7 @@ import java.sql.SQLException;
import java.sql.SQLFeatureNotSupportedException;
import tech.turso.annotations.Nullable;
import tech.turso.annotations.SkipNullableCheck;
import tech.turso.core.LimboPropertiesHolder;
import tech.turso.core.TursoPropertiesHolder;
import tech.turso.utils.Logger;
import tech.turso.utils.LoggerFactory;
@@ -18,22 +18,37 @@ public final class JDBC4DatabaseMetaData implements DatabaseMetaData {
private static final Logger logger = LoggerFactory.getLogger(JDBC4DatabaseMetaData.class);
private final JDBC4Connection connection;
@Nullable private PreparedStatement getTables = null;
@Nullable private PreparedStatement getTableTypes = null;
@Nullable private PreparedStatement getTypeInfo = null;
@Nullable private PreparedStatement getCatalogs = null;
@Nullable private PreparedStatement getSchemas = null;
@Nullable private PreparedStatement getUDTs = null;
@Nullable private PreparedStatement getColumnsTblName = null;
@Nullable private PreparedStatement getSuperTypes = null;
@Nullable private PreparedStatement getSuperTables = null;
@Nullable private PreparedStatement getTablePrivileges = null;
@Nullable private PreparedStatement getIndexInfo = null;
@Nullable private PreparedStatement getProcedures = null;
@Nullable private PreparedStatement getProcedureColumns = null;
@Nullable private PreparedStatement getAttributes = null;
@Nullable private PreparedStatement getBestRowIdentifier = null;
@Nullable private PreparedStatement getVersionColumns = null;
@Nullable private PreparedStatement getColumnPrivileges = null;
public JDBC4DatabaseMetaData(JDBC4Connection connection) {
@@ -88,7 +103,7 @@ public final class JDBC4DatabaseMetaData implements DatabaseMetaData {
@Override
public String getDatabaseProductName() {
return "Limbo";
return "turso";
}
@Override
@@ -99,12 +114,12 @@ public final class JDBC4DatabaseMetaData implements DatabaseMetaData {
@Override
public String getDriverName() {
return LimboPropertiesHolder.getDriverName();
return TursoPropertiesHolder.getDriverName();
}
@Override
public String getDriverVersion() {
return LimboPropertiesHolder.getDriverVersion();
return TursoPropertiesHolder.getDriverVersion();
}
@Override
@@ -174,13 +189,13 @@ public final class JDBC4DatabaseMetaData implements DatabaseMetaData {
@Override
public String getSQLKeywords() {
// TODO: add more limbo supported keywords
return "ABORT,ACTION,AFTER,ANALYZE,ATTACH,AUTOINCREMENT,BEFORE,"
// TODO: add more turso supported keywords
return ("ABORT,ACTION,AFTER,ANALYZE,ATTACH,AUTOINCREMENT,BEFORE,"
+ "CASCADE,CONFLICT,DATABASE,DEFERRABLE,DEFERRED,DESC,DETACH,"
+ "EXCLUSIVE,EXPLAIN,FAIL,GLOB,IGNORE,INDEX,INDEXED,INITIALLY,INSTEAD,ISNULL,"
+ "KEY,LIMIT,NOTNULL,OFFSET,PLAN,PRAGMA,QUERY,"
+ "RAISE,REGEXP,REINDEX,RENAME,REPLACE,RESTRICT,"
+ "TEMP,TEMPORARY,TRANSACTION,VACUUM,VIEW,VIRTUAL";
+ "TEMP,TEMPORARY,TRANSACTION,VACUUM,VIEW,VIRTUAL");
}
@Override
@@ -318,7 +333,7 @@ public final class JDBC4DatabaseMetaData implements DatabaseMetaData {
// DECLARE CURSOR
// FETCH
// CLOSE CURSOR
// TODO: Let's return true when limbo supports them all
// TODO: Let's return true when turso supports them all
return false;
}
@@ -331,7 +346,7 @@ public final class JDBC4DatabaseMetaData implements DatabaseMetaData {
// Table expressions (SELECT column FROM (SELECT * FROM table) AS subquery)
// Data type support (includes more SQL data types like FLOAT, NUMERIC, DECIMAL)
// Basic string functions (e.g., LENGTH(), SUBSTRING(), CONCAT())
// TODO: Let's return true when limbo supports them all
// TODO: Let's return true when turso supports them all
return false;
}
@@ -392,7 +407,7 @@ public final class JDBC4DatabaseMetaData implements DatabaseMetaData {
@Override
public boolean isCatalogAtStart() {
// sqlite and limbo doesn't use catalog
// sqlite and turso doesn't use catalog
return false;
}
@@ -498,13 +513,13 @@ public final class JDBC4DatabaseMetaData implements DatabaseMetaData {
@Override
public boolean supportsUnion() {
// TODO: return true when limbo supports
// TODO: return true when turso supports
return false;
}
@Override
public boolean supportsUnionAll() {
// TODO: return true when limbo supports
// TODO: return true when turso supports
return false;
}
@@ -635,13 +650,13 @@ public final class JDBC4DatabaseMetaData implements DatabaseMetaData {
@Override
public int getDefaultTransactionIsolation() {
// TODO: after limbo introduces Hekaton MVCC, what should we return?
// TODO: after turso introduces Hekaton MVCC, what should we return?
return Connection.TRANSACTION_SERIALIZABLE;
}
@Override
public boolean supportsTransactions() {
// TODO: limbo doesn't support transactions fully, let's return true when supported
// TODO: turso doesn't support transactions fully, let's return true when supported
return false;
}
@@ -922,7 +937,7 @@ public final class JDBC4DatabaseMetaData implements DatabaseMetaData {
@Override
public boolean supportsResultSetConcurrency(int type, int concurrency) {
return type == ResultSet.TYPE_FORWARD_ONLY && concurrency == ResultSet.CONCUR_READ_ONLY;
return (type == ResultSet.TYPE_FORWARD_ONLY && concurrency == ResultSet.CONCUR_READ_ONLY);
}
@Override
@@ -1001,13 +1016,13 @@ public final class JDBC4DatabaseMetaData implements DatabaseMetaData {
@Override
public boolean supportsSavepoints() {
// TODO: return true when limbo supports save points
// TODO: return true when turso supports save points
return false;
}
@Override
public boolean supportsNamedParameters() {
// TODO: return true when both limbo and jdbc supports named parameters
// TODO: return true when both turso and jdbc supports named parameters
return false;
}

5
bindings/java/src/main/java/tech/turso/jdbc4/JDBC4PreparedStatement.java
View File

@@ -23,7 +23,7 @@ import java.sql.Time;
import java.sql.Timestamp;
import java.util.Calendar;
import tech.turso.annotations.SkipNullableCheck;
import tech.turso.core.LimboResultSet;
import tech.turso.core.TursoResultSet;
public final class JDBC4PreparedStatement extends JDBC4Statement implements PreparedStatement {
@@ -32,7 +32,6 @@ public final class JDBC4PreparedStatement extends JDBC4Statement implements Prep
public JDBC4PreparedStatement(JDBC4Connection connection, String sql) throws SQLException {
super(connection);
this.sql = sql;
this.statement = connection.prepare(sql);
this.statement.initializeColumnMetadata();
@@ -48,7 +47,7 @@ public final class JDBC4PreparedStatement extends JDBC4Statement implements Prep
@Override
public int executeUpdate() throws SQLException {
requireNonNull(this.statement);
final LimboResultSet resultSet = statement.getResultSet();
final TursoResultSet resultSet = statement.getResultSet();
resultSet.consumeAll();
// TODO: return updated count

6
bindings/java/src/main/java/tech/turso/jdbc4/JDBC4ResultSet.java
View File

@@ -24,13 +24,13 @@ import java.util.Calendar;
import java.util.Map;
import tech.turso.annotations.Nullable;
import tech.turso.annotations.SkipNullableCheck;
import tech.turso.core.LimboResultSet;
import tech.turso.core.TursoResultSet;
public final class JDBC4ResultSet implements ResultSet, ResultSetMetaData {
private final LimboResultSet resultSet;
private final TursoResultSet resultSet;
public JDBC4ResultSet(LimboResultSet resultSet) {
public JDBC4ResultSet(TursoResultSet resultSet) {
this.resultSet = resultSet;
}

11
bindings/java/src/main/java/tech/turso/jdbc4/JDBC4Statement.java
View File

@@ -10,15 +10,16 @@ import java.sql.Statement;
import java.util.concurrent.locks.ReentrantLock;
import tech.turso.annotations.Nullable;
import tech.turso.annotations.SkipNullableCheck;
import tech.turso.core.LimboResultSet;
import tech.turso.core.LimboStatement;
import tech.turso.core.TursoResultSet;
import tech.turso.core.TursoStatement;
public class JDBC4Statement implements Statement {
private final JDBC4Connection connection;
@Nullable protected LimboStatement statement = null;
// Because JDBC4Statement has different life cycle in compared to LimboStatement, let's use this
@Nullable protected TursoStatement statement = null;
// Because JDBC4Statement has different life cycle in compared to tursoStatement, let's use this
// field to manage JDBC4Statement lifecycle
private boolean closed;
private boolean closeOnCompletion;
@@ -76,7 +77,7 @@ public class JDBC4Statement implements Statement {
execute(sql);
requireNonNull(statement, "statement should not be null after running execute method");
final LimboResultSet resultSet = statement.getResultSet();
final TursoResultSet resultSet = statement.getResultSet();
resultSet.consumeAll();
return (int) (statement.totalChanges() - previousTotalChanges);

19
bindings/java/src/main/java/tech/turso/utils/LimboExceptionUtils.java → bindings/java/src/main/java/tech/turso/utils/TursoExceptionUtils.java
View File

@@ -3,21 +3,22 @@ package tech.turso.utils;
import static tech.turso.utils.ByteArrayUtils.utf8ByteBufferToString;
import java.sql.SQLException;
import tech.turso.LimboErrorCode;
import tech.turso.TursoErrorCode;
import tech.turso.annotations.Nullable;
import tech.turso.exceptions.LimboException;
import tech.turso.exceptions.TursoException;
public final class TursoExceptionUtils {
public final class LimboExceptionUtils {
/**
* Throws formatted SQLException with error code and message.
*
* @param errorCode Error code.
* @param errorMessageBytes Error message.
*/
public static void throwLimboException(int errorCode, byte[] errorMessageBytes)
public static void throwTursoException(int errorCode, byte[] errorMessageBytes)
throws SQLException {
String errorMessage = utf8ByteBufferToString(errorMessageBytes);
throw buildLimboException(errorCode, errorMessage);
throw buildTursoException(errorCode, errorMessage);
}
/**
@@ -26,16 +27,16 @@ public final class LimboExceptionUtils {
* @param errorCode Error code.
* @param errorMessage Error message.
*/
public static LimboException buildLimboException(int errorCode, @Nullable String errorMessage)
public static TursoException buildTursoException(int errorCode, @Nullable String errorMessage)
throws SQLException {
LimboErrorCode code = LimboErrorCode.getErrorCode(errorCode);
TursoErrorCode code = TursoErrorCode.getErrorCode(errorCode);
String msg;
if (code == LimboErrorCode.UNKNOWN_ERROR) {
if (code == TursoErrorCode.UNKNOWN_ERROR) {
msg = String.format("%s:%s (%s)", code, errorCode, errorMessage);
} else {
msg = String.format("%s (%s)", code, errorMessage);
}
return new LimboException(msg, code);
return new TursoException(msg, code);
}
}

2
bindings/java/src/main/resources/limbo-jdbc.properties → bindings/java/src/main/resources/turso-jdbc.properties
View File

@@ -1,3 +1,3 @@
driverName=limbo-jdbc
driverName=turso-jdbc
# find a way to relate driverVersion with project.version defined in gradle.properties
driverVersion=0.0.1-SNAPSHOT

2
bindings/java/src/test/java/tech/turso/IntegrationTest.java
View File

@@ -15,7 +15,7 @@ public class IntegrationTest {
@BeforeEach
void setUp() throws Exception {
String filePath = TestUtils.createTempFile();
String url = "jdbc:sqlite:" + filePath;
String url = "jdbc:turso:" + filePath;
connection = new JDBC4Connection(url, filePath, new Properties());
}

10
bindings/java/src/test/java/tech/turso/JDBCTest.java
View File

@@ -22,26 +22,26 @@ class JDBCTest {
@Test
void non_null_connection_is_returned_when_valid_url_is_passed() throws Exception {
String fileUrl = TestUtils.createTempFile();
JDBC4Connection connection = JDBC.createConnection("jdbc:sqlite:" + fileUrl, new Properties());
JDBC4Connection connection = JDBC.createConnection("jdbc:turso:" + fileUrl, new Properties());
assertThat(connection).isNotNull();
}
@Test
void connection_can_be_retrieved_from_DriverManager() throws SQLException {
try (Connection connection = DriverManager.getConnection("jdbc:sqlite:sample.db")) {
try (Connection connection = DriverManager.getConnection("jdbc:turso:sample.db")) {
assertThat(connection).isNotNull();
}
}
@Test
void retrieve_version() {
assertDoesNotThrow(() -> DriverManager.getDriver("jdbc:sqlite:").getMajorVersion());
assertDoesNotThrow(() -> DriverManager.getDriver("jdbc:sqlite:").getMinorVersion());
assertDoesNotThrow(() -> DriverManager.getDriver("jdbc:turso:").getMajorVersion());
assertDoesNotThrow(() -> DriverManager.getDriver("jdbc:turso:").getMinorVersion());
}
@Test
void all_driver_property_info_should_have_a_description() throws Exception {
Driver driver = DriverManager.getDriver("jdbc:sqlite:");
Driver driver = DriverManager.getDriver("jdbc:turso:");
assertThat(driver.getPropertyInfo(null, null))
.allSatisfy((info) -> assertThat(info.description).isNotNull());
}

2
bindings/java/src/test/java/tech/turso/TestUtils.java
View File

@@ -6,6 +6,6 @@ import java.nio.file.Files;
public class TestUtils {
/** Create temporary file and returns the path. */
public static String createTempFile() throws IOException {
return Files.createTempFile("limbo_test_db", null).toAbsolutePath().toString();
return Files.createTempFile("turso_test_db", null).toAbsolutePath().toString();
}
}

16
bindings/java/src/test/java/tech/turso/core/LimboDBFactoryTest.java → bindings/java/src/test/java/tech/turso/core/TursoDBFactoryTest.java
View File

@@ -7,14 +7,14 @@ import java.util.Properties;
import org.junit.jupiter.api.Test;
import tech.turso.TestUtils;
class LimboDBFactoryTest {
class TursoDBFactoryTest {
@Test
void single_database_should_be_created_when_urls_are_same() throws Exception {
String filePath = TestUtils.createTempFile();
String url = "jdbc:sqlite:" + filePath;
LimboDB db1 = LimboDBFactory.open(url, filePath, new Properties());
LimboDB db2 = LimboDBFactory.open(url, filePath, new Properties());
String url = "jdbc:turso:" + filePath;
TursoDB db1 = TursoDBFactory.open(url, filePath, new Properties());
TursoDB db2 = TursoDBFactory.open(url, filePath, new Properties());
assertEquals(db1, db2);
}
@@ -22,10 +22,10 @@ class LimboDBFactoryTest {
void multiple_databases_should_be_created_when_urls_differ() throws Exception {
String filePath1 = TestUtils.createTempFile();
String filePath2 = TestUtils.createTempFile();
String url1 = "jdbc:sqlite:" + filePath1;
String url2 = "jdbc:sqlite:" + filePath2;
LimboDB db1 = LimboDBFactory.open(url1, filePath1, new Properties());
LimboDB db2 = LimboDBFactory.open(url2, filePath2, new Properties());
String url1 = "jdbc:turso:" + filePath1;
String url2 = "jdbc:turso:" + filePath2;
TursoDB db1 = TursoDBFactory.open(url1, filePath1, new Properties());
TursoDB db2 = TursoDBFactory.open(url2, filePath2, new Properties());
assertNotEquals(db1, db2);
}
}

32
bindings/java/src/test/java/tech/turso/core/LimboDBTest.java → bindings/java/src/test/java/tech/turso/core/TursoDBTest.java
View File

@@ -6,25 +6,25 @@ import static org.junit.jupiter.api.Assertions.assertFalse;
import java.sql.SQLException;
import org.junit.jupiter.api.Test;
import tech.turso.LimboErrorCode;
import tech.turso.TestUtils;
import tech.turso.exceptions.LimboException;
import tech.turso.TursoErrorCode;
import tech.turso.exceptions.TursoException;
public class LimboDBTest {
public class TursoDBTest {
@Test
void db_should_open_normally() throws Exception {
LimboDB.load();
TursoDB.load();
String dbPath = TestUtils.createTempFile();
LimboDB db = LimboDB.create("jdbc:sqlite" + dbPath, dbPath);
TursoDB db = TursoDB.create("jdbc:turso" + dbPath, dbPath);
db.open(0);
}
@Test
void db_should_close_normally() throws Exception {
LimboDB.load();
TursoDB.load();
String dbPath = TestUtils.createTempFile();
LimboDB db = LimboDB.create("jdbc:sqlite" + dbPath, dbPath);
TursoDB db = TursoDB.create("jdbc:turso" + dbPath, dbPath);
db.open(0);
db.close();
@@ -33,9 +33,9 @@ public class LimboDBTest {
@Test
void should_throw_exception_when_opened_twice() throws Exception {
LimboDB.load();
TursoDB.load();
String dbPath = TestUtils.createTempFile();
LimboDB db = LimboDB.create("jdbc:sqlite:" + dbPath, dbPath);
TursoDB db = TursoDB.create("jdbc:turso:" + dbPath, dbPath);
db.open(0);
assertThatThrownBy(() -> db.open(0)).isInstanceOf(SQLException.class);
@@ -43,17 +43,17 @@ public class LimboDBTest {
@Test
void throwJavaException_should_throw_appropriate_java_exception() throws Exception {
LimboDB.load();
TursoDB.load();
String dbPath = TestUtils.createTempFile();
LimboDB db = LimboDB.create("jdbc:sqlite:" + dbPath, dbPath);
TursoDB db = TursoDB.create("jdbc:turso:" + dbPath, dbPath);
final int limboExceptionCode = LimboErrorCode.LIMBO_ETC.code;
final int tursoExceptionCode = TursoErrorCode.TURSO_ETC.code;
try {
db.throwJavaException(limboExceptionCode);
db.throwJavaException(tursoExceptionCode);
} catch (Exception e) {
assertThat(e).isInstanceOf(LimboException.class);
LimboException limboException = (LimboException) e;
assertThat(limboException.getResultCode().code).isEqualTo(limboExceptionCode);
assertThat(e).isInstanceOf(TursoException.class);
TursoException tursoException = (TursoException) e;
assertThat(tursoException.getResultCode().code).isEqualTo(tursoExceptionCode);
}
}
}

32
bindings/java/src/test/java/tech/turso/core/LimboStatementTest.java → bindings/java/src/test/java/tech/turso/core/TursoStatementTest.java
View File

@@ -12,20 +12,20 @@ import org.junit.jupiter.api.Test;
import tech.turso.TestUtils;
import tech.turso.jdbc4.JDBC4Connection;
class LimboStatementTest {
class TursoStatementTest {
private JDBC4Connection connection;
@BeforeEach
void setUp() throws Exception {
String filePath = TestUtils.createTempFile();
String url = "jdbc:sqlite:" + filePath;
String url = "jdbc:turso:" + filePath;
connection = new JDBC4Connection(url, filePath, new Properties());
}
@Test
void closing_statement_closes_related_resources() throws Exception {
LimboStatement stmt = connection.prepare("SELECT 1;");
TursoStatement stmt = connection.prepare("SELECT 1;");
stmt.execute();
stmt.close();
@@ -38,9 +38,9 @@ class LimboStatementTest {
runSql("CREATE TABLE users (name TEXT, age INT, country TEXT);");
runSql("INSERT INTO users VALUES ('seonwoo', 30, 'KR');");
final LimboStatement stmt = connection.prepare("SELECT * FROM users");
final TursoStatement stmt = connection.prepare("SELECT * FROM users");
stmt.initializeColumnMetadata();
final LimboResultSet rs = stmt.getResultSet();
final TursoResultSet rs = stmt.getResultSet();
final String[] columnNames = rs.getColumnNames();
assertEquals("name", columnNames[0]);
@@ -51,12 +51,12 @@ class LimboStatementTest {
@Test
void test_bindNull() throws Exception {
runSql("CREATE TABLE test (col1 TEXT);");
LimboStatement stmt = connection.prepare("INSERT INTO test (col1) VALUES (?);");
TursoStatement stmt = connection.prepare("INSERT INTO test (col1) VALUES (?);");
stmt.bindNull(1);
stmt.execute();
stmt.close();
LimboStatement selectStmt = connection.prepare("SELECT col1 FROM test;");
TursoStatement selectStmt = connection.prepare("SELECT col1 FROM test;");
selectStmt.execute();
assertNull(selectStmt.getResultSet().get(1));
selectStmt.close();
@@ -65,12 +65,12 @@ class LimboStatementTest {
@Test
void test_bindLong() throws Exception {
runSql("CREATE TABLE test (col1 BIGINT);");
LimboStatement stmt = connection.prepare("INSERT INTO test (col1) VALUES (?);");
TursoStatement stmt = connection.prepare("INSERT INTO test (col1) VALUES (?);");
stmt.bindLong(1, 123456789L);
stmt.execute();
stmt.close();
LimboStatement selectStmt = connection.prepare("SELECT col1 FROM test;");
TursoStatement selectStmt = connection.prepare("SELECT col1 FROM test;");
selectStmt.execute();
assertEquals(123456789L, selectStmt.getResultSet().get(1));
selectStmt.close();
@@ -79,12 +79,12 @@ class LimboStatementTest {
@Test
void test_bindDouble() throws Exception {
runSql("CREATE TABLE test (col1 DOUBLE);");
LimboStatement stmt = connection.prepare("INSERT INTO test (col1) VALUES (?);");
TursoStatement stmt = connection.prepare("INSERT INTO test (col1) VALUES (?);");
stmt.bindDouble(1, 3.14);
stmt.execute();
stmt.close();
LimboStatement selectStmt = connection.prepare("SELECT col1 FROM test;");
TursoStatement selectStmt = connection.prepare("SELECT col1 FROM test;");
selectStmt.execute();
assertEquals(3.14, selectStmt.getResultSet().get(1));
selectStmt.close();
@@ -93,12 +93,12 @@ class LimboStatementTest {
@Test
void test_bindText() throws Exception {
runSql("CREATE TABLE test (col1 TEXT);");
LimboStatement stmt = connection.prepare("INSERT INTO test (col1) VALUES (?);");
TursoStatement stmt = connection.prepare("INSERT INTO test (col1) VALUES (?);");
stmt.bindText(1, "hello");
stmt.execute();
stmt.close();
LimboStatement selectStmt = connection.prepare("SELECT col1 FROM test;");
TursoStatement selectStmt = connection.prepare("SELECT col1 FROM test;");
selectStmt.execute();
assertEquals("hello", selectStmt.getResultSet().get(1));
selectStmt.close();
@@ -107,20 +107,20 @@ class LimboStatementTest {
@Test
void test_bindBlob() throws Exception {
runSql("CREATE TABLE test (col1 BLOB);");
LimboStatement stmt = connection.prepare("INSERT INTO test (col1) VALUES (?);");
TursoStatement stmt = connection.prepare("INSERT INTO test (col1) VALUES (?);");
byte[] blob = {1, 2, 3, 4, 5};
stmt.bindBlob(1, blob);
stmt.execute();
stmt.close();
LimboStatement selectStmt = connection.prepare("SELECT col1 FROM test;");
TursoStatement selectStmt = connection.prepare("SELECT col1 FROM test;");
selectStmt.execute();
assertArrayEquals(blob, (byte[]) selectStmt.getResultSet().get(1));
selectStmt.close();
}
private void runSql(String sql) throws Exception {
LimboStatement stmt = connection.prepare(sql);
TursoStatement stmt = connection.prepare(sql);
while (stmt.execute()) {
stmt.execute();
}

2
bindings/java/src/test/java/tech/turso/jdbc4/JDBC4ConnectionTest.java
View File

@@ -17,7 +17,7 @@ class JDBC4ConnectionTest {
@BeforeEach
void setUp() throws Exception {
String filePath = TestUtils.createTempFile();
String url = "jdbc:sqlite:" + filePath;
String url = "jdbc:turso:" + filePath;
connection = new JDBC4Connection(url, filePath, new Properties());
}

2
bindings/java/src/test/java/tech/turso/jdbc4/JDBC4DatabaseMetaDataTest.java
View File

@@ -22,7 +22,7 @@ class JDBC4DatabaseMetaDataTest {
@BeforeEach
void set_up() throws Exception {
String filePath = TestUtils.createTempFile();
String url = "jdbc:sqlite:" + filePath;
String url = "jdbc:turso:" + filePath;
connection = new JDBC4Connection(url, filePath, new Properties());
metaData = new JDBC4DatabaseMetaData(connection);
}

2
bindings/java/src/test/java/tech/turso/jdbc4/JDBC4PreparedStatementTest.java
View File

@@ -21,7 +21,7 @@ class JDBC4PreparedStatementTest {
@BeforeEach
void setUp() throws Exception {
String filePath = TestUtils.createTempFile();
String url = "jdbc:sqlite:" + filePath;
String url = "jdbc:turso:" + filePath;
connection = new JDBC4Connection(url, filePath, new Properties());
}

2
bindings/java/src/test/java/tech/turso/jdbc4/JDBC4ResultSetTest.java
View File

@@ -27,7 +27,7 @@ class JDBC4ResultSetTest {
@BeforeEach
void setUp() throws Exception {
String filePath = TestUtils.createTempFile();
String url = "jdbc:sqlite:" + filePath;
String url = "jdbc:turso:" + filePath;
final JDBC4Connection connection = new JDBC4Connection(url, filePath, new Properties());
stmt =
connection.createStatement(

8
bindings/java/src/test/java/tech/turso/jdbc4/JDBC4StatementTest.java
View File

@@ -21,7 +21,7 @@ class JDBC4StatementTest {
@BeforeEach
void setUp() throws Exception {
String filePath = TestUtils.createTempFile();
String url = "jdbc:sqlite:" + filePath;
String url = "jdbc:turso:" + filePath;
final JDBC4Connection connection = new JDBC4Connection(url, filePath, new Properties());
stmt =
connection.createStatement(
@@ -38,20 +38,20 @@ class JDBC4StatementTest {
@Test
void execute_insert_should_return_false() throws Exception {
stmt.execute("CREATE TABLE users (id INTEGER PRIMARY KEY, username TEXT);");
assertFalse(stmt.execute("INSERT INTO users VALUES (1, 'limbo');"));
assertFalse(stmt.execute("INSERT INTO users VALUES (1, 'turso');"));
}
@Test
void execute_update_should_return_false() throws Exception {
stmt.execute("CREATE TABLE users (id INTEGER PRIMARY KEY, username TEXT);");
stmt.execute("INSERT INTO users VALUES (1, 'limbo');");
stmt.execute("INSERT INTO users VALUES (1, 'turso');");
assertFalse(stmt.execute("UPDATE users SET username = 'seonwoo' WHERE id = 1;"));
}
@Test
void execute_select_should_return_true() throws Exception {
stmt.execute("CREATE TABLE users (id INTEGER PRIMARY KEY, username TEXT);");
stmt.execute("INSERT INTO users VALUES (1, 'limbo');");
stmt.execute("INSERT INTO users VALUES (1, 'turso');");
assertTrue(stmt.execute("SELECT * FROM users;"));
}

1
bindings/java/src/test/resources/turso/.rustc_info.json Normal file
View File

@@ -0,0 +1 @@
{"rustc_fingerprint":11551670960185020797,"outputs":{"14427667104029986310":{"success":true,"status":"","code":0,"stdout":"rustc 1.83.0 (90b35a623 2024-11-26)\nbinary: rustc\ncommit-hash: 90b35a6239c3d8bdabc530a6a0816f7ff89a0aaf\ncommit-date: 2024-11-26\nhost: x86_64-unknown-linux-gnu\nrelease: 1.83.0\nLLVM version: 19.1.1\n","stderr":""},"11399821309745579047":{"success":true,"status":"","code":0,"stdout":"___\nlib___.rlib\nlib___.so\nlib___.so\nlib___.a\nlib___.so\n/home/merlin/.rustup/toolchains/1.83.0-x86_64-unknown-linux-gnu\noff\npacked\nunpacked\n___\ndebug_assertions\npanic=\"unwind\"\nproc_macro\ntarget_abi=\"\"\ntarget_arch=\"x86_64\"\ntarget_endian=\"little\"\ntarget_env=\"gnu\"\ntarget_family=\"unix\"\ntarget_feature=\"fxsr\"\ntarget_feature=\"sse\"\ntarget_feature=\"sse2\"\ntarget_has_atomic=\"16\"\ntarget_has_atomic=\"32\"\ntarget_has_atomic=\"64\"\ntarget_has_atomic=\"8\"\ntarget_has_atomic=\"ptr\"\ntarget_os=\"linux\"\ntarget_pointer_width=\"64\"\ntarget_vendor=\"unknown\"\nunix\n","stderr":""}},"successes":{}}

3
bindings/java/src/test/resources/turso/CACHEDIR.TAG Normal file
View File

@@ -0,0 +1,3 @@
Signature: 8a477f597d28d172789f06886806bc55
# This file is a cache directory tag created by cargo.
# For information about cache directory tags see https://bford.info/cachedir/