| /* |
| * Copyright (C) 2008 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| package libcore.sqlite; |
| |
| import SQLite.Constants; |
| import SQLite.Database; |
| import SQLite.Stmt; |
| import SQLite.TableResult; |
| import java.sql.Connection; |
| import tests.support.DatabaseCreator; |
| import tests.support.Support_SQL; |
| |
| public class OldStmtTest extends OldSQLiteTest { |
| |
| private Database db; |
| private Stmt st; |
| |
| private static final String CREATE_ALL_TYPES = "create table type (" |
| + " BoolVal BOOLEAN," |
| + " IntVal INT," |
| + " LongVal LONG," |
| + " Bint BIGINT," |
| + " Tint TINYINT," |
| + " Sint SMALLINT," |
| + " Mint MEDIUMINT," |
| + " IntegerVal INTEGER," |
| + " RealVal REAL," |
| + " DoubleVal DOUBLE," |
| + " FloatVal FLOAT," |
| + " DecVal DECIMAL," |
| + " NumVal NUMERIC," |
| + " charStr CHAR(20)," |
| + " dateVal DATE," |
| + " timeVal TIME," |
| + " TS TIMESTAMP," |
| + " DT DATETIME," |
| + " TBlob TINYBLOB," |
| + " BlobVal BLOB," |
| + " MBlob MEDIUMBLOB," |
| + " LBlob LONGBLOB," |
| + " TText TINYTEXT," |
| + " TextVal TEXT," |
| + " MText MEDIUMTEXT," |
| + " LText LONGTEXT," |
| + " MaxLongVal BIGINT," |
| + " MinLongVal BIGINT," |
| + " validURL URL," |
| + " invalidURL URL);"; |
| |
| static final String INSERT_ALL_TYPES = "insert into type (" |
| + "BoolVal, IntVal, LongVal, Bint, Tint, Sint, Mint,IntegerVal, RealVal, DoubleVal, " |
| + "FloatVal, DecVal,NumVal, charStr, dateVal, timeVal, TS,DT, TBlob, BlobVal, MBlob, " |
| + "LBlob,TText, TextVal, MText, LText, MaxLongVal, MinLongVal, validURL, invalidURL) " |
| + "values (1, -1, 22, 2, 33,3, 1, 2, 3.9, 23.2, 33.3, 44,5, 'test string', '1799-05-26'," |
| + "'12:35:45', '2007-10-09 14:28:02.0','1221-09-22 10:11:55', 1, 2, 3, 4," |
| + "'Test text message tiny', 'Test text', 'Test text message medium'," |
| + "'Test text message long', " + Long.MAX_VALUE + ", " + Long.MIN_VALUE + "," |
| + "null, null);"; |
| |
| static final String ALL_TYPES_TABLE = "type"; |
| |
| @Override public void setUp() throws Exception { |
| super.setUp(); |
| Support_SQL.loadDriver(); |
| db = new Database(); |
| db.open(dbFile.getPath(), 0); |
| db.exec(DatabaseCreator.CREATE_TABLE_SIMPLE1, null); |
| DatabaseCreator.fillSimpleTable1(conn); |
| |
| st = new Stmt(); |
| } |
| |
| @Override public void tearDown() throws Exception { |
| if (st != null) { |
| try { |
| st.close(); |
| } catch (Exception e) { |
| } |
| } |
| db.close(); |
| Connection con = Support_SQL.getConnection(); |
| con.close(); |
| super.tearDown(); |
| } |
| |
| public void testStmt() throws Exception { |
| db.prepare(""); |
| |
| try { |
| st.step(); |
| fail("Cannot execute non prepared Stmt"); |
| } catch (SQLite.Exception expected) { |
| } |
| } |
| |
| public void testPrepare() throws Exception { |
| try { |
| st = db.prepare(""); |
| st.prepare(); |
| fail("statement is closed"); |
| } catch (SQLite.Exception expected) { |
| assertEquals("stmt already closed", expected.getMessage()); |
| } |
| |
| st = new Stmt(); |
| st = db.prepare("select * from " + DatabaseCreator.SIMPLE_TABLE1); |
| assertFalse(st.prepare()); |
| st = new Stmt(); |
| st = db.prepare("insert into " + DatabaseCreator.SIMPLE_TABLE1 |
| + " values (:one,:two,:three)"); |
| assertFalse(st.prepare()); |
| st = new Stmt(); |
| st = db.prepare("insert into " + DatabaseCreator.SIMPLE_TABLE1 |
| + " values (:one,:two,:three)"); |
| st.bind(1, 1); |
| st.bind(2, 10); |
| st.bind(3, 30); |
| assertFalse(st.prepare()); |
| st = db.prepare("select * from " + DatabaseCreator.SIMPLE_TABLE1 |
| + "; " + "delete from " + DatabaseCreator.SIMPLE_TABLE1 |
| + " where id = 5; " + "insert into " |
| + DatabaseCreator.SIMPLE_TABLE1 + " values(5, 10, 20); " |
| + "select * from " + DatabaseCreator.SIMPLE_TABLE1 + ";"); |
| assertTrue(st.prepare()); |
| assertTrue(st.prepare()); |
| assertTrue(st.prepare()); |
| assertFalse(st.prepare()); |
| } |
| |
| public void testStep() throws Exception { |
| try { |
| st.step(); |
| fail("Exception expected"); |
| } catch (SQLite.Exception expected) { |
| assertEquals("stmt already closed", expected.getMessage()); |
| } |
| |
| st = new Stmt(); |
| st = db.prepare("select name from sqlite_master where type = 'table'"); |
| st.step(); |
| } |
| |
| public void testClose() throws Exception { |
| st = db.prepare("insert into " + DatabaseCreator.SIMPLE_TABLE1 |
| + " values (:one,:two,:three)"); |
| st.close(); |
| |
| try { |
| st.step(); |
| fail("Test fails"); |
| } catch (SQLite.Exception expected) { |
| assertEquals("stmt already closed", expected.getMessage()); |
| } |
| } |
| |
| public void testReset() throws Exception { |
| db.exec("create table TEST (res integer not null)", null); |
| |
| st = db.prepare("insert into TEST values (:one);"); |
| st.bind(1, 1); |
| st.step(); |
| |
| // verify that parameter is still bound |
| st.reset(); |
| assertEquals(1,st.bind_parameter_count()); |
| st.step(); |
| |
| TableResult count = db.get_table("select count(*) from TEST where res=1", null); |
| |
| String[] row0 = (String[]) count.rows.elementAt(0); |
| assertEquals(2, Integer.parseInt(row0[0])); |
| } |
| |
| public void testClear_bindings() { |
| try { |
| st.clear_bindings(); |
| } catch (SQLite.Exception expected) { |
| assertEquals("unsupported", expected.getMessage()); |
| } |
| } |
| |
| public void testBindIntInt() throws Exception { |
| int input = 0; |
| int maxVal = Integer.MAX_VALUE; |
| int minVal = Integer.MIN_VALUE; |
| |
| db.exec("create table TEST (res integer)", null); |
| st = db.prepare("insert into TEST values (:one);"); |
| st.bind(1, input); |
| st.step(); |
| |
| st.reset(); |
| st.bind(1,maxVal); |
| st.step(); |
| |
| st.reset(); |
| st.bind(1,minVal); |
| st.step(); |
| |
| TableResult r = db.get_table("select * from TEST"); |
| |
| String[] row0 = (String[]) r.rows.elementAt(0); |
| assertEquals(input,Integer.parseInt(row0[0])); |
| |
| String[] row1 = (String[]) r.rows.elementAt(1); |
| assertEquals(maxVal,Integer.parseInt(row1[0])); |
| |
| String[] row2 = (String[]) r.rows.elementAt(2); |
| assertEquals(minVal,Integer.parseInt(row2[0])); |
| |
| try { |
| st.close(); |
| st.bind(1,Integer.MIN_VALUE); |
| fail("Exception expected"); |
| } catch (SQLite.Exception expected) { |
| } |
| } |
| |
| public void testBindIntLong() throws Exception { |
| long input = 0; |
| long maxVal = Long.MAX_VALUE; |
| long minVal = Long.MIN_VALUE; |
| |
| db.exec("create table TEST (res long)", null); |
| st = db.prepare("insert into TEST values (:one);"); |
| st.bind(1, input); |
| st.step(); |
| |
| st.reset(); |
| st.bind(1,maxVal); |
| st.step(); |
| |
| st.reset(); |
| st.bind(1,minVal); |
| st.step(); |
| |
| TableResult r = db.get_table("select * from TEST"); |
| |
| String[] row0 = (String[]) r.rows.elementAt(0); |
| assertEquals(input,Long.parseLong(row0[0])); |
| |
| String[] row1 = (String[]) r.rows.elementAt(1); |
| assertEquals(maxVal,Long.parseLong(row1[0])); |
| |
| String[] row2 = (String[]) r.rows.elementAt(2); |
| assertEquals(minVal,Long.parseLong(row2[0])); |
| |
| try { |
| st.close(); |
| st.bind(1,Long.MIN_VALUE); |
| fail("Exception expected"); |
| } catch (SQLite.Exception expected) { |
| } |
| } |
| |
| public void testBindIntDouble() throws Exception { |
| double input = 0.0; |
| double maxVal = Double.MAX_VALUE; |
| double minVal = Double.MIN_VALUE; |
| double negInf = Double.NEGATIVE_INFINITY; |
| double posInf = Double.POSITIVE_INFINITY; |
| double nan = Double.NaN; |
| |
| db.exec("create table TEST (res double)", null); |
| st = db.prepare("insert into TEST values (:one);"); |
| st.bind(1, input); |
| st.step(); |
| |
| st.reset(); |
| st.bind(1, maxVal); |
| st.step(); |
| |
| st.reset(); |
| st.bind(1, minVal); |
| st.step(); |
| |
| st.reset(); |
| st.bind(1, negInf); |
| st.step(); |
| |
| st.reset(); |
| st.bind(1, posInf); |
| st.step(); |
| |
| st.reset(); |
| st.bind(1, nan); |
| st.step(); |
| |
| |
| TableResult r = db.get_table("select * from TEST"); |
| |
| String[] row0 = (String[]) r.rows.elementAt(0); |
| assertTrue(Double.compare(input, Double.parseDouble(row0[0])) == 0); |
| |
| String[] row1 = (String[]) r.rows.elementAt(1); |
| assertFalse(Double.compare(maxVal, Double.parseDouble(row1[0])) == 0); |
| assertTrue(Double.compare(maxVal, Double.parseDouble(row1[0])) < 0); |
| assertTrue(Double.isInfinite(Double.parseDouble(row1[0]))); |
| |
| String[] row2 = (String[]) r.rows.elementAt(2); |
| assertTrue(Double.compare(minVal, Double.parseDouble(row2[0])) == 0); |
| |
| String[] row3 = (String[]) r.rows.elementAt(3); |
| assertEquals("Double.NEGATIVE_INFINITY SQLite representation", |
| "-Inf", row3[0]); |
| |
| String[] row4 = (String[]) r.rows.elementAt(4); |
| assertEquals("Double.POSITIVE_INFINITY SQLite representation", |
| "Inf", row4[0]); |
| |
| String[] row5 = (String[]) r.rows.elementAt(4); |
| assertEquals("Double.Nan SQLite representation", "Inf", row5[0]); |
| |
| try { |
| st.close(); |
| st.bind(1,0.0); |
| fail("Exception expected"); |
| } catch (SQLite.Exception expected) { |
| } |
| } |
| |
| public void testBindIntByteArray() throws Exception { |
| String name = "Hello World"; |
| byte[] b = name.getBytes(); |
| String stringInHex = ""; |
| |
| db.exec(DatabaseCreator.CREATE_TABLE_PARENT, null); |
| st = db.prepare("insert into " + DatabaseCreator.PARENT_TABLE |
| + " values (:one, :two);"); |
| st.bind(1, 2); |
| st.bind(2, b); |
| st.step(); |
| |
| //compare what was stored with input based on Hex representation |
| // since type of column is CHAR |
| TableResult r = db.get_table("select * from " |
| + DatabaseCreator.PARENT_TABLE); |
| String[] row = (String[]) r.rows.elementAt(0); |
| |
| for (byte aByte : b) { |
| stringInHex += Integer.toHexString(aByte); |
| } |
| stringInHex = "X'" + stringInHex + "'"; |
| assertTrue(stringInHex.equalsIgnoreCase(row[1])); |
| |
| try { |
| st.close(); |
| st.bind(1,name.getBytes()); |
| fail("Exception expected"); |
| } catch (SQLite.Exception expected) { |
| } |
| } |
| |
| public void testBindIntString() throws Exception { |
| String name = "Hello World"; |
| db.exec(DatabaseCreator.CREATE_TABLE_PARENT, null); |
| st = db.prepare("insert into " + DatabaseCreator.PARENT_TABLE |
| + " values (:one, :two);"); |
| st.bind(1, 2); |
| st.bind(2, name); |
| st.step(); |
| |
| TableResult r = db.get_table("select * from " |
| + DatabaseCreator.PARENT_TABLE); |
| String[] row = (String[]) r.rows.elementAt(0); |
| assertEquals(name,row[1]); |
| |
| try { |
| st.close(); |
| st.bind(1,name); |
| fail("Exception expected"); |
| } catch (SQLite.Exception expected) { |
| } |
| } |
| |
| public void testBindInt() throws Exception { |
| try { |
| st = db.prepare("insert into " + DatabaseCreator.SIMPLE_TABLE1 |
| + " values (:one,:two,:three)"); |
| st.bind(4); |
| st.bind(1, 4); |
| st.bind(2, 10); |
| st.bind(3, 30); |
| st.step(); |
| fail(); |
| } catch (SQLite.Exception expected) { |
| // What happens if null is bound to non existing variable position |
| assertEquals("parameter position out of bounds", expected.getMessage()); |
| } |
| |
| // functional tests |
| |
| try { |
| st.reset(); |
| st.bind(1); |
| st.bind(2, 10); |
| st.bind(3, 30); |
| st.step(); |
| fail(); |
| } catch (SQLite.Exception expected) { |
| // What happens if null is bound to NON NULL field |
| assertEquals("SQL logic error or missing database", expected.getMessage()); |
| } |
| |
| st.reset(); |
| st.bind(1, 3); |
| st.bind(2); |
| st.bind(3, 30); |
| st.step(); |
| } |
| |
| public void testBind_zeroblob() { |
| try { |
| st.bind_zeroblob(1, 128); |
| fail(); |
| } catch (SQLite.Exception expected) { |
| assertEquals("unsupported", expected.getMessage()); |
| } |
| } |
| |
| public void testBind_parameter_count() throws Exception { |
| try { |
| st.bind_parameter_count(); |
| fail(); |
| } catch (SQLite.Exception expected) { |
| assertEquals("stmt already closed", expected.getMessage()); |
| } |
| |
| st = db.prepare("insert into " + DatabaseCreator.SIMPLE_TABLE1 |
| + " values (:one,:two,:three)"); |
| assertEquals(3, st.bind_parameter_count()); |
| |
| st = db.prepare("insert into " + DatabaseCreator.SIMPLE_TABLE1 |
| + " values (?, ?, ?)"); |
| assertEquals(3, st.bind_parameter_count()); |
| |
| st = db.prepare("select * from " + DatabaseCreator.SIMPLE_TABLE1); |
| assertEquals(0, st.bind_parameter_count()); |
| |
| try { |
| st.close(); |
| st.bind_parameter_count(); |
| fail("Exception expected"); |
| } catch (SQLite.Exception expected) { |
| } |
| |
| } |
| |
| public void testBind_parameter_name() { |
| try { |
| st.bind_parameter_name(1); |
| fail("Exception expected"); |
| } catch (SQLite.Exception expected) { |
| assertEquals("stmt already closed", expected.getMessage()); |
| } |
| |
| try { |
| st = db.prepare("insert into " + DatabaseCreator.SIMPLE_TABLE1 |
| + " values (:one,:two,:three)"); |
| assertEquals(":one", st.bind_parameter_name(1)); |
| assertEquals(":two", st.bind_parameter_name(2)); |
| assertEquals(":three", st.bind_parameter_name(3)); |
| st.bind_parameter_name(4); |
| fail(); |
| } catch (SQLite.Exception expected) { |
| assertEquals("parameter position out of bounds", expected.getMessage()); |
| } |
| } |
| |
| public void testBind_parameter_index() throws Exception { |
| try { |
| st.bind_parameter_index(""); |
| fail("Exception expected"); |
| } catch (SQLite.Exception expected) { |
| assertEquals("stmt already closed", expected.getMessage()); |
| } |
| |
| st = db.prepare("insert into " + DatabaseCreator.SIMPLE_TABLE1 |
| + " values (:one,:two,:three)"); |
| assertEquals(3, st.bind_parameter_index(":three")); |
| |
| st = db.prepare("insert into " + DatabaseCreator.SIMPLE_TABLE1 |
| + " values (:one,:two,:three)"); |
| assertEquals(0, st.bind_parameter_index(":t")); |
| |
| st = db.prepare("insert into " + DatabaseCreator.SIMPLE_TABLE1 |
| + " values (?, ?, ?)"); |
| assertEquals(0, st.bind_parameter_index("?")); |
| } |
| |
| public void testColumn_int() throws Exception { |
| db.exec(CREATE_ALL_TYPES, null); |
| db.exec(INSERT_ALL_TYPES, null); |
| |
| Object columnObject; |
| int intColumn; |
| String selectStmt = "select * from "+DatabaseCreator.SIMPLE_TABLE1; |
| |
| st = db.prepare(selectStmt); |
| st.step(); |
| // select 'speed' value |
| columnObject = st.column(1); |
| intColumn = st.column_int(1); |
| assertNotNull(intColumn); |
| |
| assertTrue("Integer".equalsIgnoreCase(st.column_decltype(1))); |
| int stSpeed = Integer.parseInt(columnObject.toString()); |
| assertNotNull(stSpeed); |
| assertEquals( intColumn, stSpeed); |
| assertEquals(10,stSpeed); |
| |
| selectStmt = "select TextVal from "+ ALL_TYPES_TABLE; |
| |
| st = db.prepare(selectStmt); |
| st.step(); |
| st.column_int(0); |
| } |
| |
| public void testColumn_long() throws Exception { |
| Object columnObject; |
| long longColumn; |
| String selectStmt = "select * from "+DatabaseCreator.SIMPLE_TABLE1; |
| st = db.prepare(selectStmt); |
| st.step(); |
| columnObject = st.column(1); |
| longColumn = st.column_long(1); |
| assertNotNull(longColumn); |
| // column declared as integer |
| assertTrue("Integer".equalsIgnoreCase(st.column_decltype(1))); |
| int stSpeed = Integer.parseInt(columnObject.toString()); |
| assertNotNull(stSpeed); |
| assertEquals( longColumn, stSpeed); |
| |
| try { |
| st.column_long(4); |
| fail("Exception expected"); |
| } catch (SQLite.Exception expected) { |
| assertEquals("column out of bounds", expected.getMessage()); |
| } |
| |
| try { |
| st.column_long(-1); |
| fail("Exception expected"); |
| } catch (SQLite.Exception expected) { |
| assertEquals("column out of bounds", expected.getMessage()); |
| } |
| } |
| |
| public void testColumn_double() throws Exception { |
| db.exec(CREATE_ALL_TYPES, null); |
| db.exec(INSERT_ALL_TYPES, null); |
| |
| double doubleColumn; |
| double actualVal = 23.2; |
| String selectStmt = "select DoubleVal from "+ ALL_TYPES_TABLE; |
| |
| st = db.prepare(selectStmt); |
| st.step(); |
| // select double value |
| doubleColumn = st.column_double(0); |
| assertNotNull(doubleColumn); |
| |
| assertTrue("DOUBLE".equalsIgnoreCase(st.column_decltype(0))); |
| assertNotNull(doubleColumn); |
| assertEquals( actualVal, doubleColumn); |
| |
| // Exception test |
| selectStmt = "select dateVal from "+ ALL_TYPES_TABLE; |
| |
| st = db.prepare(selectStmt); |
| st.step(); |
| // select double value |
| st.column_double(0); |
| } |
| |
| public void testColumn_bytes() throws Exception { |
| db.exec("create table B(id integer primary key, val blob)",null); |
| db.exec("insert into B values(1, zeroblob(128))", null); |
| st = db.prepare("select val from B where id = 1"); |
| assertTrue(st.step()); |
| st.column_bytes(0); |
| } |
| |
| public void testColumn_string() throws Exception { |
| db.exec(CREATE_ALL_TYPES, null); |
| db.exec(INSERT_ALL_TYPES, null); |
| |
| String stringColumn; |
| String actualVal = "test string"; |
| String selectStmt = "select charStr from "+ ALL_TYPES_TABLE; |
| |
| st = db.prepare(selectStmt); |
| st.step(); |
| // select string value |
| stringColumn = st.column_string(0); |
| assertNotNull(stringColumn); |
| |
| assertTrue("CHAR(20)".equalsIgnoreCase(st.column_decltype(0))); |
| assertNotNull(stringColumn); |
| assertEquals( actualVal, stringColumn); |
| |
| // Exception test |
| selectStmt = "select DoubleVal from "+ ALL_TYPES_TABLE; |
| |
| st = db.prepare(selectStmt); |
| st.step(); |
| st.column_string(0); |
| } |
| |
| public void testColumn_type() throws Exception { |
| db.exec(CREATE_ALL_TYPES, null); |
| db.exec(INSERT_ALL_TYPES, null); |
| st = db.prepare("select * from " + ALL_TYPES_TABLE); |
| st.step(); |
| |
| // Exception test |
| try { |
| st.column_type(100); |
| fail(); |
| } catch (SQLite.Exception expected) { |
| } |
| |
| /* |
| Dictionary |
| |
| public static final int SQLITE_INTEGER = 1; |
| public static final int SQLITE_FLOAT = 2; |
| public static final int SQLITE_BLOB = 4; |
| public static final int SQLITE_NULL = 5; |
| public static final int SQLITE3_TEXT = 3; |
| public static final int SQLITE_NUMERIC = -1; |
| */ |
| |
| assertEquals(Constants.SQLITE3_TEXT, st.column_type(23)); // ok TEXT |
| assertEquals(Constants.SQLITE3_TEXT, st.column_type(13)); // CHAR(20) |
| |
| assertEquals(Constants.SQLITE_FLOAT, st.column_type(8)); |
| assertEquals(Constants.SQLITE_FLOAT, st.column_type(9)); |
| assertEquals(Constants.SQLITE_FLOAT, st.column_type(10)); // FLOAT |
| |
| for (int i = 0; i < 8; i++) { |
| assertEquals("Expected Integer at position " + i, |
| Constants.SQLITE_INTEGER, st.column_type(i)); |
| } |
| |
| assertEquals(Constants.SQLITE_NULL, st.column_type(28)); |
| assertEquals(Constants.SQLITE_NULL, st.column_type(29)); |
| |
| // Failing tests |
| assertTrue("INTEGER".equalsIgnoreCase(st.column_decltype(12))); |
| assertEquals(Constants.SQLITE_INTEGER, st.column_type(12)); |
| |
| assertTrue("FLOAT".equalsIgnoreCase(st.column_decltype(11))); |
| assertEquals(Constants.SQLITE_FLOAT, st.column_type(11)); // FLOAT -> |
| // got INTEGER |
| assertTrue("BLOB".equalsIgnoreCase(st.column_decltype(19))); |
| assertEquals(Constants.SQLITE_BLOB, st.column_type(19)); // Blob got |
| // INTEGER |
| |
| } |
| |
| /** |
| * Wrong value is returned in case of a prepared statement to which a '*' bound |
| */ |
| public void testColumn_count() throws Exception { |
| String selectStmt = "select * from "+DatabaseCreator.SIMPLE_TABLE1; |
| st = db.prepare(selectStmt); |
| |
| assertEquals(3, st.column_count()); |
| |
| st.step(); |
| int columnCount = st.column_count(); |
| assertNotNull(columnCount); |
| assertEquals( 3, columnCount); |
| |
| // actual prepared statement |
| selectStmt = "select ? from "+DatabaseCreator.SIMPLE_TABLE1; |
| st = db.prepare(selectStmt); |
| |
| assertEquals(3, st.column_count()); |
| |
| st.bind(1, "*"); |
| st.step(); |
| columnCount = st.column_count(); |
| assertNotNull(columnCount); |
| assertEquals( 3, columnCount); |
| } |
| |
| public void testColumn() throws Exception { |
| Object columnObject; |
| int intColumn; |
| String selectStmt = "select * from "+DatabaseCreator.SIMPLE_TABLE1; |
| db.get_table(selectStmt); |
| st = db.prepare(selectStmt); |
| st.step(); |
| columnObject = st.column(1); |
| intColumn = st.column_int(1); |
| assertNotNull(intColumn); |
| assertTrue("Integer".equalsIgnoreCase(st.column_decltype(1))); |
| int stSpeed = Integer.parseInt(columnObject.toString()); |
| assertNotNull(stSpeed); |
| assertEquals( intColumn, stSpeed); |
| |
| try { |
| assertNotNull(columnObject); |
| ((Integer) columnObject).intValue(); |
| fail("Cast to Integer should fail"); |
| } catch (ClassCastException expected) { |
| } |
| |
| try { |
| st.column(4); |
| fail("Exception expected"); |
| } catch (SQLite.Exception expected) { |
| assertEquals("column out of bounds", expected.getMessage()); |
| } |
| |
| try { |
| st.column(-1); |
| fail("Exception expected"); |
| } catch (SQLite.Exception expected) { |
| assertEquals("column out of bounds", expected.getMessage()); |
| } |
| } |
| |
| public void testColumn_table_name() { |
| try { |
| st = db.prepare("select * from " + DatabaseCreator.SIMPLE_TABLE1); |
| st.column_table_name(1); |
| fail("Function is now supported."); |
| } catch (SQLite.Exception expected) { |
| assertEquals("unsupported", expected.getMessage()); |
| } |
| } |
| |
| public void testColumn_database_name() { |
| try { |
| st = db.prepare("insert into " + DatabaseCreator.SIMPLE_TABLE1 |
| + " values (:one,:two,:three)"); |
| st.column_database_name(1); |
| fail("Function is now supported."); |
| } catch (SQLite.Exception expected) { |
| assertEquals("unsupported", expected.getMessage()); |
| } |
| } |
| |
| public void testColumn_decltype() throws Exception { |
| db.exec(CREATE_ALL_TYPES, null); |
| db.exec(INSERT_ALL_TYPES, null); |
| st = db.prepare("select * from " + ALL_TYPES_TABLE); |
| st.step(); |
| |
| // Exception test |
| try { |
| st.column_decltype(100); |
| fail(); |
| } catch (SQLite.Exception expected) { |
| } |
| |
| assertTrue(st.column_decltype(0), "BOOLEAN".equalsIgnoreCase(st |
| .column_decltype(0))); |
| assertTrue(st.column_decltype(1), "INT".equalsIgnoreCase(st |
| .column_decltype(1))); |
| assertTrue(st.column_decltype(2), "LONG".equalsIgnoreCase(st |
| .column_decltype(2))); |
| assertTrue(st.column_decltype(3), "BIGINT".equalsIgnoreCase(st |
| .column_decltype(3))); |
| assertTrue(st.column_decltype(4), "TINYINT".equalsIgnoreCase(st |
| .column_decltype(4))); |
| assertTrue(st.column_decltype(5), "SMALLINT".equalsIgnoreCase(st |
| .column_decltype(5))); |
| assertTrue(st.column_decltype(6), "MEDIUMINT".equalsIgnoreCase(st |
| .column_decltype(6))); |
| assertTrue(st.column_decltype(7), "INTEGER".equalsIgnoreCase(st |
| .column_decltype(7))); |
| assertTrue(st.column_decltype(8), "REAL".equalsIgnoreCase(st |
| .column_decltype(8))); |
| assertTrue(st.column_decltype(9), "DOUBLE".equalsIgnoreCase(st |
| .column_decltype(9))); |
| assertTrue(st.column_decltype(10), "FLOAT".equalsIgnoreCase(st |
| .column_decltype(10))); |
| assertTrue(st.column_decltype(11), "DECIMAL".equalsIgnoreCase(st |
| .column_decltype(11))); |
| assertTrue(st.column_decltype(12), "NUMERIC".equalsIgnoreCase(st |
| .column_decltype(12))); |
| assertTrue(st.column_decltype(13), "CHAR(20)".equalsIgnoreCase(st |
| .column_decltype(13))); |
| |
| assertTrue(st.column_decltype(19), "BLOB".equalsIgnoreCase(st |
| .column_decltype(19))); |
| |
| assertTrue(st.column_decltype(23), "TEXT".equalsIgnoreCase(st |
| .column_decltype(23))); |
| assertTrue(st.column_decltype(28), "URL".equalsIgnoreCase(st |
| .column_decltype(28))); |
| assertTrue(st.column_decltype(29), "URL".equalsIgnoreCase(st |
| .column_decltype(29))); |
| } |
| |
| public void testColumn_origin_name() { |
| try { |
| st = db.prepare("select * from " + DatabaseCreator.SIMPLE_TABLE1); |
| st.column_origin_name(1); |
| fail("Function is now supported."); |
| } catch (SQLite.Exception expected) { |
| assertEquals("unsupported", expected.getMessage()); |
| } |
| } |
| } |
