Commit 06546136d1ab06a7bb75a69c9ef5e97f0e5bb576 - csvjdbc

New upstream release. Debian Janitor 2 years ago

90 changed file(s) with 8825 addition(s) and 7410 deletion(s). Raw diff Collapse all Expand all

+16

-0

.github/workflows/maven-package.yml less more

	0	name: Java CI
	1
	2	on: [push]
	3
	4	jobs:
	5	build:
	6	runs-on: ubuntu-latest
	7
	8	steps:
	9	- uses: actions/checkout@v2
	10	- name: Set up JDK 11
	11	uses: actions/setup-java@v1
	12	with:
	13	java-version: 11
	14	- name: Build with Maven
	15	run: mvn -B clean package

-4

~~.travis.yml~~ less more

0		language: java
1		jdk:
2		- openjdk8
3		install: mvn install -DskipTests=true -Dgpg.skip=true -Dmaven.javadoc.skip=true

-74

~~RELEASE-INSTRUCTIONS.txt~~ less more

0		Instructions for creating a CsvJdbc release build/RELEASE-INSTRUCTIONS.txt
1
2		1. Check environment
3
4		java -version (must be 1.6)
5
6		2. Checkout (replace simoc with your SourceForge username)
7
8		git clone ssh://simoc@git.code.sf.net/p/csvjdbc/code csvjdbc-code
9		git clone ssh://simoc@git.code.sf.net/p/csvjdbc/website csvjdbc-website
10
11		3. Check that XML <property name="rel"> tag in file
12		csvjdbc-code/build/build.xml is the version number we are creating.
13		If not, update it and commit.
14
15		4. Compile
16
17		cd csvjdbc-code/build
18		ant jar test
19
20		5. Check that the ant test step above does not report failing unit tests
21
22		6. Upload to Sourceforge web site (replace simoc and 1.0-29 with values
23		for this release).
24
25		sftp simoc,csvjdbc@frs.sourceforge.net
26		cd /home/frs/project/c/cs/csvjdbc/CsvJdbc
27		mkdir 1.0-29
28		cd 1.0-29
29		put target/csvjdbc-1.0-29.jar
30
31		7. Check that XML <project><version> tag in file pom.xml is the version
32		number we are creating plus "-SNAPSHOT" suffix. If not, update it and
33		commit.
34
35		8. Check that you have a $HOME/.m2/settings.xml file containing
36		the following XML tags, as described in
37		http://central.sonatype.org/pages/apache-maven.html
38		and that the GPG profile contains a GPG key created using steps in
39		http://central.sonatype.org/pages/working-with-pgp-signatures.html
40
41		<server><id>git.code.sf.net</id> ...
42		<server><id>ossrh</id> ...
43		<profile><id>ossrh</id> ... contains GPG profile
44
45		9. Maven deploy to Maven Central
46
47		mvn release:clean release:prepare
48		(accept defaults at prompts for CsvJdbc version, git tag, next CsvJdbc
49		version number. You are also prompted for Sourceforge password several
50		times).
51		mvn release:perform
52
53		10. Login to Nexus Repository Manager https://oss.sonatype.org/
54		(username and password same as in <ossrh> XML tag in
55		$HOME/.m2/settings.xml), click on Staging Repositories in left panel,
56		then on row netsourceforgecsvjdbc- ..., then Close in toolbar and
57		Confirm in dialog box, then Release in toolbar and Confirm in dialog
58		box, as described in
59		http://central.sonatype.org/pages/releasing-the-deployment.html
60
61		11. Update Tracker tickets from 'Pending' to 'Closed' with a comment
62		that they are included in release 1.0-29.
63
64		12. Create a README.md file listing the changed Tracker tickets and
65		upload to 1.0-29 directory, as in Step 7.
66
67		13. Upload new index.html if it has changed since last release.
68
69		cd csvjdbc-website/www
70		sftp simoc@web.sourceforge.net
71		cd /home/project-web/c/cs/csvjdbc/htdocs
72		put index.html
73

-1

build/build.xml less more

35	35	<!-- =================================================================== -->
36	36	<property name="TALK" value="false" />
37	37	<property name="name" value="csvjdbc"/>
38		<property name="rel" value="1.0-36"/>
	38	<property name="rel" value="1.0-37"/>
39	39	<property name="rel.name" value="${name}-${rel}"/>
40	40	<property name="build.dir" value="../build"/>
41	41	<property name="src.dir" value="../src"/>

-0

debian/changelog less more

	0	csvjdbc (1.0.37-1) UNRELEASED; urgency=low
	1
	2	* New upstream release.
	3
	4	-- Debian Janitor <janitor@jelmer.uk> Thu, 19 Aug 2021 05:38:14 -0000
	5
0	6	csvjdbc (1.0.36+ds-1) unstable; urgency=medium
1	7
2	8	[ Mechtilde ]

+75

-0

docs/README.md less more

	0	# CsvJdbc
	1
	2	![Java CI](https://github.com/simoc/csvjdbc/workflows/Java%20CI/badge.svg)
	3
	4	A Java database driver for reading comma-separated-value files.
	5
	6	## Introduction
	7
	8	CsvJdbc is a read-only JDBC driver that uses Comma Separated Value (CSV) files
	9	or DBF files as database tables. It is ideal for writing data import programs
	10	or analyzing log files.
	11
	12	The driver enables a directory or a ZIP file containing CSV or DBF files to be
	13	accessed as though it were a database containing tables. However, as there is
	14	no real database management system behind the scenes, not all JDBC
	15	functionality is available.
	16
	17	## Usage
	18
	19	The CsvJdbc driver is used just like any other JDBC driver:
	20
	21
	22	1. download `csvjdbc.jar` and add it to the Java CLASSPATH.
	23	1. load the driver class, (its full name is `org.relique.jdbc.csv.CsvDriver`)
	24	1. use `DriverManager` to connect to the database (the directory or ZIP file)
	25	1. create a statement object
	26	1. use the statement object to execute an SQL SELECT query
	27	1. the result of the query is a `ResultSet`
	28
	29	The following example puts the above steps into practice.
	30
	31	```java
	32	import java.sql.*;
	33	import org.relique.jdbc.csv.CsvDriver;
	34
	35	public class DemoDriver
	36	{
	37	public static void main(String[] args) throws Exception
	38	{
	39	// Load the driver.
	40	Class.forName("org.relique.jdbc.csv.CsvDriver");
	41
	42	// Create a connection to directory given as first command line
	43	// parameter. Driver properties are passed in URL format
	44	// (or alternatively in a java.utils.Properties object).
	45	//
	46	// A single connection is thread-safe for use by several threads.
	47	String url = "jdbc:relique:csv:" + args[0] + "?" +
	48	"separator=;" + "&" + "fileExtension=.txt";
	49	try (Connection conn = DriverManager.getConnection(url);
	50
	51	// Create a Statement object to execute the query with.
	52	// A Statement is not thread-safe.
	53	Statement stmt = conn.createStatement();
	54
	55	// Select the ID and NAME columns from sample.csv
	56	ResultSet results = stmt.executeQuery("SELECT ID,NAME FROM sample"))
	57	{
	58	// Dump out the results to a CSV file with the same format
	59	// using CsvJdbc helper function
	60	boolean append = true;
	61	CsvDriver.writeToCsv(results, System.out, append);
	62	}
	63	}
	64	}
	65	```
	66
	67	## Documentation
	68
	69	Full documentation for CsvJdbc is found [here](doc.md).
	70
	71	## Developing
	72
	73	Read the instructions for [compiling](develop.md) CsvJdbc
	74	and for [releasing](release.md) CsvJdbc.

+58

-0

docs/develop.md less more

	0	## Building From Source
	1
	2	To checkout and build the latest source code from the
	3	[CsvJdbc git repository](https://github.com/simoc/csvjdbc.git),
	4	use the following commands ([git](http://git-scm.com/) and
	5	[Maven](http://maven.apache.org/) must first be installed).
	6
	7	cd $HOME
	8	mkdir workspace1
	9	cd workspace1
	10	git clone https://github.com/simoc/csvjdbc.git csvjdbc
	11	cd csvjdbc
	12	mvn install
	13	cd target
	14	dir csvjdbc*.jar
	15
	16	## Working With Eclipse
	17
	18	1. Start Eclipse with workspace `workspace1`
	19	2. Install the JavaCC Eclipse Plug-in from the Help ->
	20	Eclipse Marketplace... menu option
	21	3. Create a new project named `csvjdbc` using menu option
	22	File -> New -> Java Project
	23	4. Open `src/main/javacc/org/relique/jdbc/csv/where.jj` in the Eclipse
	24	Editor and then select menu option JavaCC -> Compile with javacc
	25
	26	## Maven Project Usage
	27
	28	CsvJdbc is available at [Maven Central](http://search.maven.org/).
	29	To include CsvJdbc in a [Maven](http://maven.apache.org/) project,
	30	add the following lines to the `pom.xml` file.
	31
	32	<project>
	33	...
	34
	35	<dependencies>
	36	<dependency>
	37	<groupId>net.sourceforge.csvjdbc</groupId>
	38	<artifactId>csvjdbc</artifactId>
	39	<version>1.0.35</version>
	40	</dependency>
	41	</dependencies>
	42
	43	## Contributing
	44
	45	A change to CsvJdbc must first be entered as a
	46	[Issue](https://github.com/simoc/csvjdbc/issues)
	47	before starting development.
	48	A [Pull Request](https://github.com/simoc/csvjdbc/pulls)
	49	for an issue will then be accepted or not
	50	accepted by a CsvJdbc administrator.
	51
	52	Completed changes must be provided as a [git](http://www.git-scm.com)
	53	pull request and include
	54	a unit test to test the changed functionality.
	55
	56	Label good first issue is used to identify existing
	57	issues that are suitable for new developers.

+574

-0

docs/doc.md less more

	0	## Features
	1
	2	CsvJdbc accepts all types of CSV files defined by
	3	[RFC 4180](https://tools.ietf.org/html/rfc4180).
	4
	5	CsvJdbc accepts only SQL SELECT queries from a single table and does
	6	not support INSERT, UPDATE, DELETE or CREATE statements.
	7
	8	SQL sub-queries are permitted but
	9	joins between tables in SQL SELECT queries are not yet supported.
	10
	11	SQL SELECT queries must be of the following format.
	12
	13	SELECT [DISTINCT] [table-alias.]column [[AS] alias], ...
	14	FROM table [[AS] table-alias]
	15	WHERE [NOT] condition [AND \| OR condition] ...
	16	GROUP BY column ... [HAVING condition ...]
	17	ORDER BY column [ASC \| DESC] ...
	18	LIMIT n [OFFSET n]
	19
	20	Each column is either a named column,
	21	`*`,
	22	a constant value,
	23	`NULL`,
	24	`CURRENT_DATE`,
	25	`CURRENT_TIME`,
	26	a sub-query,
	27	or an expression including functions, aggregate functions,
	28	operations `+`, `-`,
	29	`/`, `*`, `%`, `\|\|`,
	30	conditional `CASE` expressions
	31	and parentheses.
	32
	33	Supported comparisons in the optional WHERE clause are
	34	`<`,
	35	`>`,
	36	`<=`,
	37	`>=`,
	38	`=`,
	39	`!=`,
	40	`<>`,
	41	`NOT`,
	42	`BETWEEN`,
	43	`LIKE`,
	44	`IS NULL`,
	45	`IN`,
	46	`EXISTS`.
	47
	48	Use double quotes around table names or column names containing spaces
	49	or other special characters.
	50
	51	Function \|Description
	52	----------- \|-------------------
	53	ABS(N) \|Returns absolute value of N
	54	COALESCE(N1, N2, ...)\|Returns first expression that is not NULL
	55	DAYOFMONTH(D) \|Extracts day of month from date or timestamp D (first day of month is 1)
	56	HOUROFDAY(T) \|Extracts hour of day from time or timestamp T
	57	LENGTH(S) \|Returns length of string
	58	LOWER(S) \|Converts string to lower case
	59	LTRIM(S [, T]) \|Removes leading characters from S that occur in T
	60	MINUTE(T) \|Extracts minute of hour from time or timestamp T
	61	MONTH(D) \|Extracts month from date or timestamp D (first month is 1)
	62	NULLIF(X, Y) \|Returns NULL if X and Y are equal, otherwise X
	63	ROUND(N) \|Rounds N to nearest whole number
	64	RTRIM(S, [, T]) \|Removes trailing characters from S that occur in T
	65	SECOND(T) \|Extracts seconds value from time or timestamp T
	66	SUBSTRING(S, N [, L])\|Extracts substring from S starting at index N (counting from 1) with length L
	67	TRIM(S, [, T]) \|Removes leading and trailing characters from S that occur in T
	68	UPPER(S) \|Converts string to lower case
	69	YEAR(D) \|Extracts year from date or timestamp D
	70
	71	Additional functions are defined from java methods using the
	72	`function.NAME` driver property.
	73
	74	Aggregate Function\|Description
	75	------------------\|-----------
	76	AVG(N) \|Average of all values
	77	COUNT(N) \|Count of all values
	78	MAX(N) \|Maximum value
	79	MIN(N) \|Minimum value
	80	STRING_AGG(S, D) \|All values of S concatenated with delimiter D
	81	SUM(N) \|Sum of all values
	82
	83	For queries containing `ORDER BY`, all records are read into memory and sorted.
	84	For queries containing `GROUP BY` plus an aggregate function, all records are
	85	read into memory and grouped. For queries that produce a scrollable result set,
	86	all records up to the furthest accessed record are held into memory. For other
	87	queries, CsvJdbc holds only one record at a time in memory.
	88
	89	## Dependencies
	90
	91	CsvJdbc requires Java version 8, or later. For reading DBF files,
	92	[DANS DBF Library](http://dans-dbf-lib.sourceforge.net/)
	93	must be downloaded and included in the CLASSPATH.
	94
	95	## Advanced Usage
	96
	97	Like other databases, creating a scrollable statement enables scrolling
	98	forwards and backwards through result sets. This is demonstrated in the
	99	following example.
	100
	101	```java
	102	import java.sql.*;
	103
	104	public class DemoDriver2
	105	{
	106	public static void main(String[] args) throws Exception
	107	{
	108	Class.forName("org.relique.jdbc.csv.CsvDriver");
	109	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + args[0]);
	110
	111	// create a scrollable Statement so we can move forwards and backwards
	112	// through ResultSets
	113	Statement stmt = conn.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE,
	114	ResultSet.CONCUR_READ_ONLY);
	115	ResultSet results = stmt.executeQuery("SELECT ID,NAME FROM sample"))
	116	{
	117
	118	// dump out the last record in the result set, then the first record
	119	if (results.last())
	120	{
	121	System.out.println("ID= " + results.getString("ID") +
	122	" NAME= " + results.getString("NAME"));
	123	if (results.first())
	124	{
	125	System.out.println("ID= " + results.getString("ID") +
	126	" NAME= " + results.getString("NAME"));
	127	}
	128	}
	129	}
	130	}
	131	}
	132	```
	133
	134	To read several files (for example, daily log files) as a single table,
	135	set the database connection property `indexedFiles`.
	136	The following example demonstrates how to do this.
	137
	138	```java
	139	import java.sql.*;
	140	import java.util.Properties;
	141
	142	public class DemoDriver3
	143	{
	144	public static void main(String[] args) throws Exception
	145	{
	146	Class.forName("org.relique.jdbc.csv.CsvDriver");
	147	Properties props = new Properties();
	148	props.put("fileExtension", ".txt");
	149	props.put("indexedFiles", "true");
	150	// We want to read test-001-20081112.txt, test-002-20081113.txt and many
	151	// other files matching this pattern.
	152	props.put("fileTailPattern", "-(\\d+)-(\\d+)");
	153	// Make the two groups in the regular expression available as
	154	// additional table columns.
	155	props.put("fileTailParts", "Seqnr,Logdatum");
	156	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" +
	157	args[0], props);
	158	Statement stmt = conn.createStatement();
	159	ResultSet results = stmt.executeQuery("SELECT Datum, Station, " +
	160	"Seqnr, Logdatum FROM test"))
	161	{
	162	ResultSetMetaData meta = results.getMetaData();
	163	while (results.next())
	164	{
	165	for (int i = 0; i < meta.getColumnCount(); i++)
	166	{
	167	System.out.println(meta.getColumnName(i + 1) + " " +
	168	results.getString(i + 1));
	169	}
	170	}
	171	}
	172	}
	173	}
	174	```
	175
	176	Set the database connection property `columnTypes` to enable expressions
	177	containing numeric, time and date data types to be used in SELECT statements
	178	and to enable column values to be fetched using `ResultSet.getInt`,
	179	`getDouble`, `getTime` and other `ResultSet.get` methods.
	180
	181	```java
	182	import java.sql.*;
	183	import java.util.Properties;
	184
	185	public class DemoDriver4
	186	{
	187	public static void main(String[] args) throws Exception
	188	{
	189	Class.forName("org.relique.jdbc.csv.CsvDriver");
	190	Properties props = new Properties();
	191	// Define column names and column data types here.
	192	props.put("suppressHeaders", "true");
	193	props.put("headerline", "ID,ANGLE,MEASUREDATE");
	194	props.put("columnTypes", "Int,Double,Date");
	195	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" +
	196	args[0], props);
	197	Statement stmt = conn.createStatement();
	198	ResultSet results = stmt.executeQuery("SELECT Id, Angle * 180 / 3.1415 as A, " +
	199	"MeasureDate FROM t1 where Id > 1001"))
	200	{
	201	while (results.next())
	202	{
	203	// Fetch column values with methods that match the column data types.
	204	System.out.println(results.getInt(1));
	205	System.out.println(results.getDouble(2));
	206	System.out.println(results.getDate(3));
	207	}
	208	}
	209	}
	210	}
	211	```
	212
	213	To read the compressed files inside a ZIP file as database tables, make a
	214	database connection to the ZIP file using the JDBC connection string format
	215	`jdbc:relique:csv:zip:filename.zip`. This is demonstrated in the following
	216	example.
	217
	218	```java
	219	import java.sql.*;
	220
	221	public class DemoDriver5
	222	{
	223	public static void main(String[] args) throws Exception
	224	{
	225	Class.forName("org.relique.jdbc.csv.CsvDriver");
	226	String zipFilename = args[0];
	227	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:zip:" +
	228	zipFilename);
	229	Statement stmt = conn.createStatement();
	230	// Read from file mytable.csv inside the ZIP file
	231	ResultSet results = stmt.executeQuery("SELECT * FROM mytable"))
	232	{
	233	while (results.next())
	234	{
	235	System.out.println(results.getString("COUNTRY"));
	236	}
	237	}
	238	}
	239	}
	240	```
	241
	242	To read data that is either held inside the Java application (for example, in a
	243	JAR file) or accessed remotely (for example, using HTTP requests), create a
	244	Java class that implements the interface `org.relique.io.TableReader` and give
	245	this class name in the connection URL. CsvJdbc then creates an instance of this
	246	class and calls the `getReader` method to obtain a `java.io.Reader` for each
	247	database table being read. This is demonstrated in the following two Java
	248	classes.
	249
	250	```java
	251	import java.io.*;
	252	import java.net.*;
	253	import java.sql.*;
	254	import java.util.*;
	255
	256	import org.relique.io.TableReader;
	257
	258	public class MyHTTPReader implements TableReader
	259	{
	260	public Reader getReader(Statement statement, String tableName) throws SQLException
	261	{
	262	try
	263	{
	264	URL url = new URL("http://csvjdbc.sourceforge.net/" + tableName + ".csv");
	265	HttpURLConnection connection = (HttpURLConnection) url.openConnection();
	266	InputStreamReader reader = new InputStreamReader(connection.getInputStream());
	267	return reader;
	268	}
	269	catch (Exception e)
	270	{
	271	throw new SQLException(e.getMessage());
	272	}
	273	}
	274	public List getTableNames(Connection connection)
	275	{
	276	// Return list of available table names
	277	Vector v = new Vector();
	278	v.add("sample");
	279	return v;
	280	}
	281	}
	282
	283
	284	import java.sql.*;
	285	import org.relique.jdbc.csv.CsvDriver;
	286
	287	public class DemoDriver6
	288	{
	289	public static void main(String []args) throws Exception
	290	{
	291	Class.forName("org.relique.jdbc.csv.CsvDriver");
	292	String sql = "SELECT * FROM sample";
	293	// Give name of Java class that provides database tables.
	294	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:class:" +
	295	MyHTTPReader.class.getName());
	296	Statement stmt = conn.createStatement();
	297	ResultSet results = stmt.executeQuery(sql))
	298	{
	299	CsvDriver.writeToCsv(results, System.out, true);
	300	}
	301	}
	302	}
	303	```
	304
	305	## Driver Properties
	306
	307	The driver also supports a number of parameters that change the
	308	default behaviour of the driver.
	309
	310	These properties are:
	311
	312	### charset
	313
	314	+ type: String
	315	+ default: Java default
	316	+ Defines the character set name of the files being read, such as `UTF-16`.
	317	See the Java
	318	[Charset](https://docs.oracle.com/javase/7/docs/api/java/nio/charset/Charset.html)
	319	documentation for a list of available character set names.
	320
	321	### columnTypes
	322
	323	+ type: String
	324	+ default: all Strings
	325	+ A comma-separated list defining SQL data types for columns in tables. When
	326	column values are fetched using `getObject` (as opposed to `getString`), the
	327	driver will parse the value and return a correctly typed object. If fewer data
	328	types are provided than the number of columns in the table, the last data type
	329	is repeated for all remaining columns. If `columnTypes` is set to an empty
	330	string then column types are inferred from the data. When working with multiple
	331	tables with different column types, define properties named `columnTypes.CATS`
	332	and `columnTypes.DOGS` to define different column types for tables `CATS` and
	333	`DOGS`.
	334
	335	### commentChar
	336
	337	+ type: String
	338	+ default: `null`
	339	+ Lines before the header that start with the comment are skipped.
	340	After the header has been read, all lines are interpreted as data.
	341
	342	### cryptoFilterClassName
	343
	344	+ type: Class
	345	+ default: `null`
	346	+ The full class name of a Java class that decrypts the file being read.
	347	The class must implement interface `org.relique.io.CryptoFilter`. The class
	348	`org.relique.io.XORFilter` included in CsvJdbc implements an XOR encryption
	349	filter.
	350
	351	### cryptoFilterParameterTypes
	352	+ type: String
	353	+ default: `String`
	354	+ Comma-separated list of data types to pass to the constructor of the
	355	decryption class set in property `cryptoFilterClassName`.
	356
	357	### cryptoFilterParameters
	358	+ type: String
	359	+ default:
	360	+ Comma-separated list of values to pass to the constructor of the
	361	decryption class set in property `cryptoFilterClassName`.
	362
	363	### defectiveHeaders
	364	+ type: Boolean
	365	+ default: `False`
	366	+ in case a column name is the emtpy string, replace it with COLUMNx,
	367	where x is the ordinal identifying the column.
	368
	369	### fileExtension
	370	+ type: String
	371	+ default: `.csv`
	372	+ Specifies file extension of the CSV files. If the extension `.dbf`
	373	is used then files are read as dBase format database files.
	374
	375	### fileTailParts
	376	+ type: String
	377	+ default: `null`
	378	+ Comma-separated list of column names for the additional columns
	379	generated by regular expression groups in the property `fileTailPattern`.
	380
	381	### fileTailPattern
	382	+ type: String
	383	+ default: `null`
	384	+ Regular expression for matching filenames when property `indexedFiles` is
	385	True. If the regular expression contains groups (surrounded by parentheses)
	386	then the value of each group in matching filenames is added as an extra column
	387	to each line read from that file. For example, when querying table `test`, the
	388	regular expression `-(\d+)-(\d+)` will match files `test-001-20081112.csv` and
	389	`test-002-20081113.csv`. The column values `001` and `20081112` are added to
	390	each line read from the first file and `002` and `20081113` are added to each
	391	line read from the second file.
	392
	393	### fileTailPrepend
	394	+ type: Boolean
	395	+ default: `False`
	396	+ when True, columns generated by regular expression groups in the
	397	`fileTailPattern` property are prepended to the start of each line.
	398	When False, the generated columns are appended after the columns
	399	read for each line.
	400
	401	### fixedWidths
	402	+ type: String
	403	+ default: `null`
	404	+ Defines character position ranges for each column in a fixed width file. When
	405	set, column values are extracted from these ranges in each line instead of
	406	separating the line by delimiters. Each column is a pair of character positions
	407	separated by a minus sign, or a single character for columns with only a single
	408	character. The position of the first character on each line is 1. Character
	409	position ranges are separated by commas. For example, `1,2-9,16-19`.
	410
	411	### function.NAME
	412	+ type: String
	413	+ default: None
	414	+ Defines a java method to use as the SQL function named `NAME` in SQL
	415	statements. The property value is a public static java given as a java package,
	416	class and method name followed by parameter list in parentheses. For example,
	417	property `function.POW` with value `java.lang.Math.pow(double, double)` makes
	418	`POW` available as an SQL function. Methods with variable length argument lists
	419	are defined by appending ... after the last parameter. Each method parameter
	420	must be a numeric type, `String`, or `Object`.
	421
	422	### headerline
	423	+ type: string
	424	+ default: None
	425	+ Used in combination with the `suppressHeaders` property to specify a custom
	426	header line for tables. `headerline` contains a list of column names for tables
	427	separated by the `separator`. When working with multiple tables with different
	428	headers, define properties named `headerline.CATS` and `headerline.DOGS` to
	429	define different header lines for tables `CATS` and `DOGS`.
	430
	431	### ignoreNonParseableLines
	432	+ type: Boolean
	433	+ default: `False`
	434	+ when True, lines that have too few or too many column values
	435	will not cause an exception but will
	436	be ignored. Each ignored line is logged. Call method
	437	`java.sql.DriverManager.setLogWriter` before executing a query to capture a
	438	list of ignored lines.
	439
	440	### indexedFiles
	441	+ type: Boolean
	442	+ default: `False`
	443	+ when True, all files with a filename matching the table name plus the regular
	444	expression given in property `fileTailPattern` are read as if they were a single
	445	file.
	446
	447	### isHeaderFixedWidth
	448	+ type: Boolean
	449	+ default: `True`
	450	+ Used in combination with the `fixedWidths` property when reading fixed
	451	width files to specify whether the header line containing the column names
	452	is also fixed width. If False, column names are separated by the `separator`.
	453
	454	### missingValue
	455	+ type: String
	456	+ default: `null`
	457	+ When not null, lines with too few column values will use this value for
	458	each missing column, instead of throwing an exception.
	459
	460	### quotechar
	461	+ type: Character
	462	+ default: `"`
	463	+ Defines quote character. Column values surrounded with the quote character
	464	are parsed with the quote characters removed. This is useful when values
	465	contain the `separator` or line breaks. No more than one character is allowed.
	466	An empty value disables quoting.
	467
	468	### quoteStyle
	469	+ type: String
	470	+ default: `SQL`
	471	+ Defines how a quote character is interpreted inside a quoted value. When
	472	`SQL`, a pair of quote characters together is interpreted as a single quote
	473	character. When `C`, a backslash followed by a quote character is interpreted
	474	as a single quote character.
	475
	476	### locale
	477	+ type: String
	478	+ default: Java default
	479	+ Defines locale to use when parsing timestamps. This is important when parsing
	480	words such as `December` which vary depending on the locale. Call method
	481	`java.util.Locale.toString()` to convert a locale to a string.
	482
	483	### separator
	484	+ type: String
	485	+ default: `","`
	486	+ Defines column separator. A separator longer than one character is permitted.
	487
	488	### skipLeadingLines
	489	+ type: Integer
	490	+ default: `0`
	491	+ after opening a file, skip this many lines before starting to interpret
	492	the contents.
	493
	494	### skipLeadingDataLines
	495	+ type: Integer
	496	+ default: `0`
	497	+ after reading the header from a file, skip this many lines before starting
	498	to interpret lines as records.
	499
	500	### suppressHeaders
	501	+ type: boolean
	502	+ default: `False`
	503	+ Used to specify that the file does not contain a column header with column
	504	names. If `True` and `headerline` is not set, then columns are named
	505	sequentially `COLUMN1`, `COLUMN2`, ... If `False`, the column header is read
	506	from the first line of the file.
	507
	508	### timestampFormat, timeFormat, dateFormat
	509	+ type: String
	510	+ default: `yyyy-MM-dd HH:mm:ss`, `HH:mm:ss`, `yyyy-MM-dd`
	511	+ Defines the format from which columns of type Timestamp, Time and Date are parsed. See the Java
	512	[SimpleDateFormat](https://docs.oracle.com/javase/7/docs/api/java/text/SimpleDateFormat.html)
	513	documentation for date and timestamp patterns,
	514	or
	515	[DateTimeFormatter](https://docs.oracle.com/javase/8/docs/api/java/time/format/DateTimeFormatter.html)
	516	when property `useDateTimeFormatter` is set to `true`.
	517
	518	### timeZoneName
	519	+ type: String
	520	+ default: `UTC`
	521	+ The time zone of Timestamp columns. To use the time zone of the computer,
	522	set this to the value returned by the method
	523	`java.util.TimeZone.getDefault().getID()`.
	524
	525	### trimHeaders
	526	+ type: Boolean
	527	+ default: `True`
	528	+ If True, leading and trailing whitespace is trimmed from each column
	529	name in the header line. Column names inside quotes are not trimmed.
	530
	531	### trimValues
	532	+ type: Boolean
	533	+ default: `False`
	534	+ If True, leading and trailing whitespace is trimmed from each column
	535	value in the file. Column values inside quotes are not trimmed.
	536
	537	### useDateTimeFormatter
	538	+ type: Boolean
	539	+ default: `False`
	540	+ If True, Java class
	541	[DateTimeFormatter](https://docs.oracle.com/javase/8/docs/api/java/time/format/DateTimeFormatter.html)
	542	(that was new in Java 8)
	543	is used to parse and format timestamps, times and dates instead
	544	of the older class
	545	[SimpleDateFormat](https://docs.oracle.com/javase/7/docs/api/java/text/SimpleDateFormat.html).
	546
	547	The following example code shows how some of these properties are used.
	548
	549	```java
	550	...
	551
	552	Properties props = new java.util.Properties();
	553
	554	props.put("separator", "\|"); // separator is a bar
	555	props.put("suppressHeaders", "true"); // first line contains data
	556	props.put("fileExtension", ".txt"); // file extension is .txt
	557	props.put("timeZoneName", "America/Los_Angeles"); // timestamps are Los Angeles time
	558
	559	Connection conn1 = Drivermanager.getConnection("jdbc:relique:csv:" + args[0], props);
	560
	561	...
	562
	563	// Connections using a URL string containing both directory and
	564	// properties are also accepted (class java.net.URLEncoder encodes
	565	// property values containing special characters).
	566	Connection conn2 = DriverManager.getConnection("jdbc:relique:csv:" + args[0] + "?" +
	567	"separator=" + URLEncoder.encode("\|", "UTF-8") + "&" +
	568	"quotechar=" + URLEncoder.encode("'", "UTF-8") + "&" +
	569	"fileExtension=.txt" + "&" +
	570	"suppressHeaders=true");
	571	```
	572
	573

+107

-0

docs/release.md less more

	0	## Releasing CsvJdbc
	1
	2	Use the following steps to create a CsvJdbc release.
	3
	4	* Check environment
	5
	6	```
	7	java -version
	8	```
	9
	10	must be 8.
	11
	12	* Checkout from GitHub
	13
	14	Push all changes from GitHub git repository to SourceForge repository
	15	(replace `simoc` with your GitHub and SourceForge usernames).
	16
	17	```
	18	git clone https://github.com/simoc/csvjdbc.git csvjdbc-github
	19	cd csvjdbc-github
	20	git push ssh://simoc@git.code.sf.net/p/csvjdbc/code master
	21	```
	22
	23	* Checkout from SourceForge
	24
	25	```
	26	git clone ssh://simoc@git.code.sf.net/p/csvjdbc/code csvjdbc-code
	27	git clone ssh://simoc@git.code.sf.net/p/csvjdbc/website csvjdbc-website
	28	```
	29
	30	* Check that XML `<property name="rel">` tag in file
	31	`csvjdbc-code/build/build.xml` is the version number we are creating.
	32	If not, update it and commit.
	33
	34	* Compile
	35
	36	```
	37	cd csvjdbc-code/build
	38	ant jar test
	39	```
	40
	41	* Check that the ant test step above does not report failing unit tests
	42
	43	* Upload to Sourceforge web site (replace `simoc` and `1.0-29` with values
	44	for this release).
	45
	46	```
	47	sftp simoc,csvjdbc@frs.sourceforge.net
	48	cd /home/frs/project/c/cs/csvjdbc/CsvJdbc
	49	mkdir 1.0-29
	50	cd 1.0-29
	51	put target/csvjdbc-1.0-29.jar
	52	```
	53
	54	* Check that XML `<project><version>` tag in file `pom.xml` is the version
	55	number we are creating plus "-SNAPSHOT" suffix. If not, update it and
	56	commit.
	57
	58	* Check that you have a `$HOME/.m2/settings.xml` file containing
	59	the following XML tags, as described
	60	[here](http://central.sonatype.org/pages/apache-maven.html)
	61	and that the GPG profile contains a GPG key created using
	62	[these steps](http://central.sonatype.org/pages/working-with-pgp-signatures.html)
	63
	64	```
	65	<server><id>git.code.sf.net</id> ...
	66	<server><id>ossrh</id> ...
	67	<profile><id>ossrh</id> ... contains GPG profile
	68	```
	69
	70	* Maven deploy to Maven Central
	71
	72	```
	73	mvn release:clean release:prepare
	74	```
	75
	76	(accept defaults at prompts for CsvJdbc version, git tag, next CsvJdbc
	77	version number. You are also prompted for Sourceforge password several
	78	times).
	79
	80	```
	81	mvn release:perform
	82	```
	83
	84	* Login to [Nexus Repository Manager](https://oss.sonatype.org/)
	85	(username and password same as in `<ossrh>` XML tag in
	86	`$HOME/.m2/settings.xml`), click on Staging Repositories in left panel,
	87	then on row netsourceforgecsvjdbc- ..., then Close in toolbar and
	88	Confirm in dialog box, then Release in toolbar and Confirm in dialog
	89	box, as described
	90	[here](http://central.sonatype.org/pages/releasing-the-deployment.html).
	91
	92	* Update Tracker tickets from 'Pending' to 'Closed' with a comment
	93	that they are included in release 1.0-29.
	94
	95	* Create a `README.md` file listing the changed Tracker tickets and
	96	upload to 1.0-29 directory, as in Step 7.
	97
	98	* Upload new `index.html` if it has changed since last release.
	99
	100	```
	101	cd csvjdbc-website/www
	102	sftp simoc@web.sourceforge.net
	103	cd /home/project-web/c/cs/csvjdbc/htdocs
	104	put index.html
	105	```
	106

-5

pom.xml less more

2	2	<modelVersion>4.0.0</modelVersion>
3	3	<groupId>net.sourceforge.csvjdbc</groupId>
4	4	<artifactId>csvjdbc</artifactId>
5		<version>1.0.36</version>
	5	<version>1.0.37</version>
6	6	<packaging>jar</packaging>
7	7	<name>CsvJdbc</name>
8	8	<description>a Java JDBC driver for reading comma-separated-value files</description>

17	17
18	18	<scm>
19	19	<connection>scm:git:ssh://git.code.sf.net/p/csvjdbc/code</connection>
20		<tag>csvjdbc-1.0.36</tag>
	20	<tag>csvjdbc-1.0.37</tag>
21	21	<url>http://sourceforge.net/p/csvjdbc/_list/git</url>
22	22	</scm>
23	23

104	104	<artifactId>maven-compiler-plugin</artifactId>
105	105	<version>2.3.2</version>
106	106	<configuration>
107		<source>1.6</source>
108		<target>1.6</target>
	107	<source>1.8</source>
	108	<target>1.8</target>
109	109	</configuration>
110	110	</plugin>
111	111	<plugin>

173	173	<dependency>
174	174	<groupId>junit</groupId>
175	175	<artifactId>junit</artifactId>
176		<version>4.11</version>
	176	<version>4.13.1</version>
177	177	<scope>test</scope>
178	178	</dependency>
179	179	</dependencies>

-1

src/main/java/org/relique/io/EncryptedFileInputStream.java less more

32	32	in = new BufferedInputStream(new FileInputStream(fileName));
33	33	}
34	34
	35	@Override
35	36	public int read() throws IOException
36	37	{
37	38	if (filter != null)

40	41	return in.read();
41	42	}
42	43
	44	@Override
43	45	public int read(byte[] b, int off, int len) throws IOException
44	46	{
45	47	if (filter != null)

48	50	return in.read(b, off, len);
49	51	}
50	52
51		public int read(InputStream in, byte[] b) throws IOException
	53	@Override
	54	public int read(byte[] b) throws IOException
52	55	{
53	56	if (filter != null)
54	57	return filter.read(in, b);

56	59	return in.read(b);
57	60	}
58	61
	62	@Override
59	63	public void close() throws IOException
60	64	{
61	65	if (in != null)

-0

src/main/java/org/relique/io/EncryptedFileOutputStream.java less more

32	32	out = new FileOutputStream(fileName);
33	33	}
34	34
	35	@Override
35	36	public void write(int b) throws IOException
36	37	{
37	38	if (filter == null)

40	41	filter.write(out, b);
41	42	}
42	43
	44	@Override
43	45	public void close() throws IOException
44	46	{
45	47	if (out != null)

+83

-9

src/main/java/org/relique/io/FileSetInputStream.java less more

52	52	private String dataTail;
53	53	private boolean prepend;
54	54	private int lookahead = '\n';
	55	private int lookahead2 = -1;
55	56	private boolean doingTail;
56	57	private int currentLineLength;
57	58	private CryptoFilter filter;
58	59	private int skipLeadingDataLines;
	60	private String charset;
59	61	private boolean isClosed = false;
60	62
61	63	/**

79	81	*/
80	82	public FileSetInputStream(String dirName, String fileNamePattern,
81	83	String[] fieldsInName, String separator, boolean prepend,
82		boolean headerless, CryptoFilter filter, int skipLeadingDataLines)
	84	boolean headerless, CryptoFilter filter, int skipLeadingDataLines,
	85	String charset)
83	86	throws IOException
84	87	{
85	88	this.dirName = dirName;
86	89	this.filter = filter;
87	90	this.skipLeadingDataLines = skipLeadingDataLines;
	91	this.charset = charset;
88	92	if (!headerless)
89	93	this.skipLeadingDataLines++;
90	94

152	156	tail = dataTail;
153	157	currentFile = new EncryptedFileInputStream(dirName + currentFileName, filter);
154	158	lookahead = currentFile.read();
	159	if (lookahead == 0xFF && charset != null && charset.equals("UTF-16LE"))
	160	{
	161	// Skip any 0xFFFE Byte Order Mark at start of UTF-16LE file.
	162	currentFile.read();
	163	lookahead = currentFile.read();
	164	}
155	165	doingTail = prepend;
156	166	if (doingTail)
157	167	pos = 1;

199	209	{
200	210	ch = readFromTail();
201	211	if (ch != -1)
	212	{
202	213	return ch;
	214	}
203	215	doingTail = false;
204	216	currentLineLength = 0;
205	217	}

208	220	ch = lookahead;
209	221	do
210	222	{
211		lookahead = currentFile.read();
	223	if (lookahead2 != -1)
	224	{
	225	lookahead = lookahead2;
	226	lookahead2 = -1;
	227	}
	228	else
	229	{
	230	lookahead = currentFile.read();
	231	}
212	232	// we ignore \r, which breaks things on files created with MacOS9
	233	if (lookahead == '\r')
	234	{
	235	if (charset != null && charset.equals("UTF-16LE"))
	236	{
	237	// Skip '\r' and '\0' for UTF-16LE charset.
	238	int skip = currentFile.read();
	239	if (skip != 0)
	240	{
	241	// Next char is some other valid UTF-16LE character,
	242	// not a carriage return, so we need to keep
	243	// it for later.
	244	lookahead2 = skip;
	245	break;
	246	}
	247	}
	248	}
213	249	}
214	250	while (lookahead == '\r');
	251
215	252	// if we met a line border we have to output the lead/tail
216	253	if (prepend)
217	254	{

219	256	if (ch == '\n' && !(lookahead == '\n' \|\| lookahead == -1))
220	257	{
221	258	doingTail = true;
222		return readFromTail();
	259	ch = readFromTail();
	260	return ch;
223	261	}
224	262	if (lookahead == -1 && ch != '\n' && ch != -1)
225	263	{

235	273	if (currentLineLength > 0 && (ch == '\n' \|\| ch == -1))
236	274	{
237	275	doingTail = true;
238		return readFromTail();
	276	if (ch == '\n' && lookahead == 0 &&
	277	charset != null && charset.equals("UTF-16LE"))
	278	{
	279	// Skip '\n' and '\0' for UTF-16LE charset.
	280	lookahead = currentFile.read();
	281	}
	282
	283	ch = readFromTail();
	284	return ch;
239	285	}
240	286	}
241	287	if (ch < 0)

262	308	do
263	309	{
264	310	ch2 = currentFile.read();
	311
	312	if (ch2 == '\n' && charset != null && charset.equals("UTF-16LE"))
	313	{
	314	// Skip '\n' and '\0' for UTF-16LE charset.
	315	int skip = currentFile.read();
	316	if (skip != 0)
	317	{
	318	// Next char is not a newline, so keep reading.
	319	ch2 = 0;
	320	}
	321	}
265	322	}
266	323	while (ch2 != '\n' && ch2 != -1);
267	324	}

269	326	if (doingTail)
270	327	pos = 1;
271	328	lookahead = currentFile.read();
272		return read();
	329	if (lookahead == 0xFF && skipLeadingDataLines == 0 &&
	330	charset != null && charset.equals("UTF-16LE"))
	331	{
	332	// Skip any 0xFFFE Byte Order Mark at start of UTF-16LE file.
	333	currentFile.read();
	334	lookahead = currentFile.read();
	335	}
	336	ch = read();
	337	return ch;
273	338	}
274	339	currentLineLength++;
275	340	return ch;

308	373	return tail;
309	374	}
310	375
311		private int readFromTail()
312		{
313		if (pos < tail.length())
314		return tail.charAt(pos++);
	376	private int readFromTail() throws IOException
	377	{
	378	if (charset != null && charset.equals("UTF-16LE"))
	379	{
	380	byte []b = tail.getBytes(charset);
	381	if (pos < b.length)
	382	return b[pos++];
	383	}
	384	else
	385	{
	386	if (pos < tail.length())
	387	return tail.charAt(pos++);
	388	}
315	389	pos = 0;
316	390	if (readingHeader)
317	391	{

-0

src/main/java/org/relique/jdbc/csv/AndExpression.java less more

37	37	isValid = left.isValid() && right.isValid();
38	38	}
39	39	}
	40	@Override
40	41	public boolean isValid()
41	42	{
42	43	return isValid;
43	44	}
	45	@Override
44	46	public Boolean isTrue(Map<String, Object> env) throws SQLException
45	47	{
46	48	Boolean leftIsTrue = left.isTrue(env);

69	71	return Boolean.FALSE;
70	72	}
71	73	}
	74	@Override
72	75	public String toString()
73	76	{
74	77	return "AND "+left+" "+right;
75	78	}
	79	@Override
76	80	public List<String> usedColumns(Set<String> availableColumns)
77	81	{
78	82	List<String> result = new LinkedList<String>();

80	84	result.addAll(right.usedColumns(availableColumns));
81	85	return result;
82	86	}
	87	@Override
83	88	public List<AggregateFunction> aggregateFunctions()
84	89	{
85	90	List<AggregateFunction> result = new LinkedList<AggregateFunction>();

-0

src/main/java/org/relique/jdbc/csv/AsteriskExpression.java less more

28	28	{
29	29	this.expression = expression;
30	30	}
	31	@Override
31	32	public String toString()
32	33	{
33	34	return expression;
34	35	}
	36	@Override
35	37	public List<String> usedColumns(Set<String> availableColumns)
36	38	{
37	39	List<String> result = new LinkedList<String>();

-0

src/main/java/org/relique/jdbc/csv/BetweenExpression.java less more

32	32	this.left = left;
33	33	this.right = right;
34	34	}
	35	@Override
35	36	public Boolean isTrue(Map<String, Object> env) throws SQLException
36	37	{
37	38	Comparable leftValue = (Comparable)left.eval(env);

52	53	}
53	54	return Boolean.FALSE;
54	55	}
	56	@Override
55	57	public String toString()
56	58	{
57	59	return "B "+obj+" "+left+" "+right;
58	60	}
	61	@Override
59	62	public List<String> usedColumns(Set<String> availableColumns)
60	63	{
61	64	List<String> result = new LinkedList<String>();

64	67	result.addAll(right.usedColumns(availableColumns));
65	68	return result;
66	69	}
	70	@Override
67	71	public List<AggregateFunction> aggregateFunctions()
68	72	{
69	73	List<AggregateFunction> result = new LinkedList<AggregateFunction>();

+13

-8

src/main/java/org/relique/jdbc/csv/BinaryOperation.java less more

42	42	this.left = left;
43	43	this.right = right;
44	44	}
	45	@Override
45	46	public Object eval(Map<String, Object> env) throws SQLException
46	47	{
47	48	Object leftEval = left.eval(env);

99	100	else if (op == '%')
100	101	bil = bil.remainder(bir);
101	102	if (isLongExpression)
102		return new Long(bil.toString());
	103	return Long.valueOf(bil.toString());
103	104	else
104		return new Integer(bil.toString());
	105	return Integer.valueOf(bil.toString());
105	106	}
106	107	catch (ClassCastException e)
107	108	{

119	120	Number rightN = (Number)rightEval;
120	121	BigDecimal bdr = new BigDecimal(rightN.toString());
121	122	if (op == '+')
122		return new Double(bdl.add(bdr).toString());
	123	return Double.valueOf(bdl.add(bdr).toString());
123	124	if (op == '-')
124		return new Double(bdl.subtract(bdr).toString());
	125	return Double.valueOf(bdl.subtract(bdr).toString());
125	126	if (op == '*')
126		return new Double(bdl.multiply(bdr).toString());
	127	return Double.valueOf(bdl.multiply(bdr).toString());
127	128	MathContext mc = new MathContext("precision=14 roundingMode=HALF_UP");
128	129	if (op == '/')
129		return new Double(bdl.divide(bdr, mc.getPrecision(), mc.getRoundingMode()).toString());
	130	return Double.valueOf(bdl.divide(bdr, mc.getPrecision(), mc.getRoundingMode()).toString());
130	131	if (op == '%')
131		return new Double(bdl.remainder(bdr, mc).toString());
	132	return Double.valueOf(bdl.remainder(bdr, mc).toString());
132	133	}
133	134	catch (ClassCastException e)
134	135	{

215	216	{
216	217	long nMillis = ((Date)leftEval).getTime() - ((Date)(rightEval)).getTime();
217	218	long nDays = (nMillis + MILLISECONDS_PER_DAY / 2) / MILLISECONDS_PER_DAY;
218		return new Integer((int)nDays);
	219	return Integer.valueOf((int)nDays);
219	220	}
220	221	}
221	222	}

252	253	newDate = Date.valueOf(newDate.toString());
253	254	return newDate;
254	255	}
	256	@Override
255	257	public String toString()
256	258	{
257	259	return ""+operation+" "+left+" "+right;
258	260	}
	261	@Override
259	262	public List<String> usedColumns(Set<String> availableColumns)
260	263	{
261	264	List<String> result = new LinkedList<String>();

263	266	result.addAll(right.usedColumns(availableColumns));
264	267	return result;
265	268	}
	269	@Override
266	270	public List<AggregateFunction> aggregateFunctions()
267	271	{
268	272	List<AggregateFunction> result = new LinkedList<AggregateFunction>();

270	274	result.addAll(right.aggregateFunctions());
271	275	return result;
272	276	}
	277	@Override
273	278	public boolean isValid()
274	279	{
275	280	/*

-0

src/main/java/org/relique/jdbc/csv/ColumnName.java less more

36	36	return columnName;
37	37	}
38	38
	39	@Override
39	40	public Object eval(Map<String, Object> env)
40	41	{
41	42	return env.get(columnName);
42	43	}
43	44
	45	@Override
44	46	public String toString()
45	47	{
46	48	return "["+columnName+"]";
47	49	}
48	50
	51	@Override
49	52	public List<String> usedColumns(Set<String> availableColumns)
50	53	{
51	54	List<String> result = new LinkedList<String>();

+22

-1

src/main/java/org/relique/jdbc/csv/CsvConnection.java less more

116	116	private String timeFormat;
117	117	private String timeZoneName;
118	118	private Locale locale = null;
	119	private boolean useDateTimeFormatter = CsvDriver.DEFAULT_USE_DATE_TIME_FORMATTER;
119	120	private String commentChar;
120	121
121	122	private int skipLeadingLines = 0;

385	386	"String").split(",");
386	387	String[] parameterStrings = info.getProperty("cryptoFilterParameters",
387	388	"").split(",");
388		StringConverter converter = new StringConverter("", "", "", "", null);
	389	StringConverter converter = new StringConverter("", "", "", "", null, false);
389	390	Class<?>[] parameterClasses = new Class[parameterStrings.length];
390	391	Object[] parameterValues = new Object[parameterStrings.length];
391	392	for (int i = 0; i < parameterStrings.length; i++)

478	479	CsvDriver.DEFAULT_TIME_FORMAT));
479	480	setTimeZoneName(info.getProperty(CsvDriver.TIME_ZONE_NAME,
480	481	CsvDriver.DEFAULT_TIME_ZONE_NAME));
	482	if (info.getProperty(CsvDriver.USE_DATE_TIME_FORMATTER) != null)
	483	{
	484	setUseDateTimeFormatter(Boolean.parseBoolean(info.getProperty(CsvDriver.USE_DATE_TIME_FORMATTER)));
	485	}
481	486	if (info.getProperty(CsvDriver.LOCALE) != null)
482	487	{
483	488	prop = info.getProperty(CsvDriver.LOCALE);

591	596	return locale;
592	597	}
593	598
	599	public void setUseDateTimeFormatter(boolean flag)
	600	{
	601	useDateTimeFormatter = flag;
	602	}
	603
	604	public boolean getUseDateTimeFormatter()
	605	{
	606	return useDateTimeFormatter;
	607	}
	608
594	609	private void checkOpen() throws SQLException
595	610	{
596	611	if (closed)

1330	1345	// TODO Auto-generated method stub
1331	1346	}
1332	1347
	1348	@Override
1333	1349	public int getNetworkTimeout() throws SQLException
1334	1350	{
1335	1351	checkOpen();

1337	1353	return 0;
1338	1354	}
1339	1355
	1356	@Override
1340	1357	public void setNetworkTimeout(Executor executor, int milliseconds)
1341	1358	throws SQLException
1342	1359	{

1345	1362	throw new SQLFeatureNotSupportedException(CsvResources.getString("methodNotSupported") + ": Connection.setNetworkTimeout(Executor,int)");
1346	1363	}
1347	1364
	1365	@Override
1348	1366	public void abort(Executor executor) throws SQLException
1349	1367	{
1350	1368	throw new UnsupportedOperationException(CsvResources.getString("methodNotSupported") + ": Connection.abort(Executor)");
1351	1369	}
1352	1370
	1371	@Override
1353	1372	public String getSchema() throws SQLException
1354	1373	{
1355	1374	checkOpen();

1357	1376	return null;
1358	1377	}
1359	1378
	1379	@Override
1360	1380	public void setSchema(String schema) throws SQLException
1361	1381	{
1362	1382	checkOpen();

1395	1415	if (path != null)
1396	1416	{
1397	1417	File[] matchingFiles = new File(path).listFiles(new FilenameFilter() {
	1418	@Override
1398	1419	public boolean accept(File dir, String name)
1399	1420	{
1400	1421	return name.endsWith(extension);

+43

-49

src/main/java/org/relique/jdbc/csv/CsvDatabaseMetaData.java less more

131	131	String columnTypes = "String,String,String,String,Integer,String,Integer,Integer,Integer,Integer,Integer,"
132	132	+ "String,String,Integer,Integer,Integer,Integer,String,String,String,String,Short,String";
133	133	ArrayList<Object[]> columnValues = new ArrayList<Object[]>();
134		ResultSet resultSet = null;
135		ResultSet resultSet2 = null;
136		try
137		{
138		if (internalStatement == null)
139		internalStatement = (CsvStatement) createdByConnection.createStatement();
140
141		/*
142		* Find tables matching the pattern.
143		*/
144		resultSet = getTables(catalog, schemaPattern, tableNamePattern, null);
	134
	135	if (internalStatement == null)
	136	internalStatement = (CsvStatement) createdByConnection.createStatement();
	137
	138	/*
	139	* Find tables matching the pattern.
	140	*/
	141	try (ResultSet resultSet = getTables(catalog, schemaPattern, tableNamePattern, null))
	142	{
145	143	while (resultSet.next())
146		{
	144	{
147	145	String tableName = resultSet.getString(3);
148	146
149		resultSet2 = internalStatement.executeQuery("SELECT * FROM \"" + tableName + "\"");
150		ResultSetMetaData metadata = resultSet2.getMetaData();
151		int nColumns = metadata.getColumnCount();
152		Integer columnSize = Integer.valueOf(Short.MAX_VALUE);
153		Integer decimalDigits = Integer.valueOf(Short.MAX_VALUE);
154		Integer zero = Integer.valueOf(0);
155		Integer radix = Integer.valueOf(10);
156		Integer nullable = Integer.valueOf(columnNullable);
157		String remarks = null;
158		String defaultValue = null;
159
160		for (int i = 0; i < nColumns; i++)
	147	try (ResultSet resultSet2 = internalStatement.executeQuery("SELECT * FROM \"" + tableName + "\""))
161	148	{
162		String columnName = metadata.getColumnName(i + 1);
163
164		/*
165		* Only add columns matching the column pattern.
166		*/
167		if (columnNamePattern == null \|\|
168		LikePattern.matches(columnNamePattern, LikePattern.DEFAULT_ESCAPE_STRING, columnName))
	149	ResultSetMetaData metadata = resultSet2.getMetaData();
	150	int nColumns = metadata.getColumnCount();
	151	Integer columnSize = Integer.valueOf(Short.MAX_VALUE);
	152	Integer decimalDigits = Integer.valueOf(Short.MAX_VALUE);
	153	Integer zero = Integer.valueOf(0);
	154	Integer radix = Integer.valueOf(10);
	155	Integer nullable = Integer.valueOf(columnNullable);
	156	String remarks = null;
	157	String defaultValue = null;
	158
	159	for (int i = 0; i < nColumns; i++)
169	160	{
170		int columnType = metadata.getColumnType(i + 1);
171		String columnTypeName = metadata.getColumnTypeName(i + 1);
172		Object data[] = { null, null, tableName, columnName,
173		Integer.valueOf(columnType), columnTypeName,
174		columnSize, zero, decimalDigits, radix, nullable,
175		remarks, defaultValue, zero, zero, columnSize,
176		Integer.valueOf(i + 1), "YES", null, null, null, null,
177		"NO" };
178		columnValues.add(data);
	161	String columnName = metadata.getColumnName(i + 1);
	162
	163	/*
	164	* Only add columns matching the column pattern.
	165	*/
	166	if (columnNamePattern == null \|\|
	167	LikePattern.matches(columnNamePattern, LikePattern.DEFAULT_ESCAPE_STRING, columnName))
	168	{
	169	int columnType = metadata.getColumnType(i + 1);
	170	String columnTypeName = metadata.getColumnTypeName(i + 1);
	171	Object data[] = { null, null, tableName, columnName,
	172	Integer.valueOf(columnType), columnTypeName,
	173	columnSize, zero, decimalDigits, radix, nullable,
	174	remarks, defaultValue, zero, zero, columnSize,
	175	Integer.valueOf(i + 1), "YES", null, null, null, null,
	176	"NO" };
	177	columnValues.add(data);
	178	}
179	179	}
180	180	}
181		resultSet2.close();
182		resultSet2 = null;
183	181	}
184	182	}
185		finally
186		{
187		if (resultSet2 != null)
188		resultSet2.close();
189		if (resultSet != null)
190		resultSet.close();
191		}
	183
192	184	ResultSet retval = createResultSet(columnNames, columnTypes, columnValues);
193	185	return retval;
194	186	}

1308	1300	return null;
1309	1301	}
1310	1302
	1303	@Override
1311	1304	public boolean generatedKeyAlwaysReturned() throws SQLException
1312	1305	{
1313	1306	return false;
1314	1307	}
1315	1308
	1309	@Override
1316	1310	public ResultSet getPseudoColumns(String catalog, String schemaPattern,
1317	1311	String tableNamePattern, String columnNamePattern)
1318	1312	throws SQLException

+26

-4

src/main/java/org/relique/jdbc/csv/CsvDriver.java less more

20	20	import java.io.PrintStream;
21	21	import java.io.PrintWriter;
22	22	import java.io.UnsupportedEncodingException;
	23	import java.lang.reflect.InvocationTargetException;
23	24	import java.net.URLDecoder;
24	25	import java.sql.Connection;
25	26	import java.sql.Date;

33	34	import java.sql.Time;
34	35	import java.sql.Timestamp;
35	36	import java.sql.Types;
	37	import java.util.Enumeration;
36	38	import java.util.Locale;
37	39	import java.util.Properties;
38	40	import java.util.logging.Logger;

57	59	public static final String DEFAULT_TIMESTAMP_FORMAT = null;
58	60	public static final String DEFAULT_DATE_FORMAT = "YYYY-MM-DD";
59	61	public static final String DEFAULT_TIME_FORMAT = "HH:mm:ss";
	62	public static final boolean DEFAULT_USE_DATE_TIME_FORMATTER = false;
60	63	public static final String DEFAULT_COMMENT_CHAR = null;
61	64	public static final String DEFAULT_SKIP_LEADING_LINES = null;
62	65	public static final String DEFAULT_IGNORE_UNPARSEABLE_LINES = "False";

79	82	public static final String DATE_FORMAT = "dateFormat";
80	83	public static final String TIME_FORMAT = "timeFormat";
81	84	public static final String LOCALE = "locale";
	85	public static final String USE_DATE_TIME_FORMATTER = "useDateTimeFormatter";
82	86	public static final String COMMENT_CHAR = "commentChar";
83	87	public static final String SKIP_LEADING_LINES = "skipLeadingLines";
84	88	public static final String IGNORE_UNPARSEABLE_LINES = "ignoreNonParseableLines";

136	140	return null;
137	141	}
138	142
	143	Enumeration<Object> keys = info.keys();
	144	while (keys.hasMoreElements())
	145	{
	146	String key = keys.nextElement().toString();
	147	writeLog("CsvDriver:connect() - property " + key + "=" + info.getProperty(key));
	148	}
	149
139	150	// strip any properties from end of URL and set them as additional
140	151	// properties
141	152	String urlProperties = "";

198	209	throw new SQLException(CsvResources.getString("interfaceNotImplemented") +
199	210	": " + TableReader.class.getName() + ": " + className);
200	211	}
201		Object tableReaderInstance = clazz.newInstance();
	212	Object tableReaderInstance = clazz.getConstructor().newInstance();
202	213	connection = new CsvConnection((TableReader)tableReaderInstance, info, urlProperties);
203	214	}
204	215	catch (ClassNotFoundException e)

210	221	throw new SQLException(e);
211	222	}
212	223	catch (InstantiationException e)
	224	{
	225	throw new SQLException(e);
	226	}
	227	catch (InvocationTargetException e)
	228	{
	229	throw new SQLException(e);
	230	}
	231	catch (NoSuchMethodException e)
213	232	{
214	233	throw new SQLException(e);
215	234	}

267	286	return false;
268	287	}
269	288
	289	@Override
270	290	public Logger getParentLogger() throws SQLFeatureNotSupportedException
271	291	{
272	292	throw new SQLFeatureNotSupportedException(CsvResources.getString("methodNotSupported") +

299	319	String timeFormat = DEFAULT_TIME_FORMAT;
300	320	String timestampFormat = DEFAULT_TIMESTAMP_FORMAT;
301	321	String timeZoneName = DEFAULT_TIME_ZONE_NAME;
	322	boolean useDateTimeFormatter = DEFAULT_USE_DATE_TIME_FORMATTER;
302	323	Locale locale = null;
303	324
304	325	if (resultSet instanceof CsvResultSet)

316	337	timestampFormat = csvConnection.getTimestampFormat();
317	338	timeZoneName = csvConnection.getTimeZoneName();
318	339	locale = csvConnection.getLocale();
319		}
320
321		StringConverter converter = new StringConverter(dateFormat, timeFormat, timestampFormat, timeZoneName, locale);
	340	useDateTimeFormatter = csvConnection.getUseDateTimeFormatter();
	341	}
	342
	343	StringConverter converter = new StringConverter(dateFormat, timeFormat, timestampFormat, timeZoneName, locale, useDateTimeFormatter);
322	344
323	345	ResultSetMetaData meta = null;
324	346	int columnCount = 0;

+61

-81

src/main/java/org/relique/jdbc/csv/CsvMain.java less more

22	22	import java.sql.Connection;
23	23	import java.sql.DriverManager;
24	24	import java.sql.ResultSet;
25		import java.sql.SQLException;
26	25	import java.util.Properties;
27	26
28	27	/**

32	31	{
33	32	public static void main(String []args)
34	33	{
35		Connection connection = null;
36		Properties properties = null;
	34	Properties properties = new Properties();
37	35	int exitStatus = 0;
38	36
39	37	try

46	44	/*
47	45	* Read directory and properties from a Properties file.
48	46	*/
49		properties = new Properties();
50		Reader propertiesReader = new FileReader(args[argIndex + 1]);
51		try
	47	try (Reader propertiesReader = new FileReader(args[argIndex + 1]))
52	48	{
53	49	properties.load(propertiesReader);
54		}
55		finally
56		{
57		propertiesReader.close();
58	50	}
59	51	argIndex += 2;
60	52	}

74	66	}
75	67
76	68	if (argIndex < args.length)
77		{
	69	{
78	70	/*
79	71	* Connect using URL containing directory name and properties.
80	72	*/
81		if (properties != null)
82		connection = DriverManager.getConnection(args[argIndex], properties);
83		else
84		connection = DriverManager.getConnection(args[argIndex]);
85		argIndex++;
	73	try (Connection connection = DriverManager.getConnection(args[argIndex], properties))
	74	{
	75	argIndex++;
86	76
87		CsvStatement statement = (CsvStatement)connection.createStatement();
	77	CsvStatement statement = (CsvStatement)connection.createStatement();
88	78
89		BufferedReader reader;
90		boolean isStdin;
91		if (argIndex == args.length)
92		{
	79	BufferedReader reader;
	80	boolean isStdin;
	81	if (argIndex == args.length)
	82	{
	83	/*
	84	* No files given, so read stdin.
	85	*/
	86	reader = new BufferedReader(new InputStreamReader(System.in));
	87	isStdin = true;
	88	}
	89	else
	90	{
	91	reader = new BufferedReader(new FileReader(args[argIndex]));
	92	isStdin = false;
	93	argIndex++;
	94	}
	95
93	96	/*
94		* No files given, so read stdin.
	97	* Do not include header line in CSV output, if not included in source CSV file.
95	98	*/
96		reader = new BufferedReader(new InputStreamReader(System.in));
97		isStdin = true;
98		}
99		else
100		{
101		reader = new BufferedReader(new FileReader(args[argIndex]));
102		isStdin = false;
103		argIndex++;
104		}
	99	boolean writeHeaderLine = !((CsvConnection)connection).isSuppressHeaders();
105	100
106		/*
107		* Do not include header line in CSV output, if not included in source CSV file.
108		*/
109		boolean writeHeaderLine = !((CsvConnection)connection).isSuppressHeaders();
	101	/*
	102	* Read and execute each SQL statement and write results to stdout.
	103	*/
	104	do
	105	{
	106	String line;
	107	StringBuilder sb = new StringBuilder();
	108	while ((line = reader.readLine()) != null)
	109	{
	110	sb.append(line);
	111	sb.append("\n");
	112	}
	113	if (!isStdin)
	114	reader.close();
	115	reader = null;
110	116
111		/*
112		* Read and execute each SQL statement and write results to stdout.
113		*/
114		do
115		{
116		String line;
117		StringBuilder sb = new StringBuilder();
118		while ((line = reader.readLine()) != null)
119		{
120		sb.append(line);
121		sb.append("\n");
122		}
123		if (!isStdin)
124		reader.close();
125		reader = null;
	117	if (statement.execute(sb.toString()))
	118	{
	119	ResultSet resultSet = statement.getResultSet();
	120	CsvDriver.writeToCsv(resultSet, System.out, writeHeaderLine);
126	121
127		if (statement.execute(sb.toString()))
128		{
129		ResultSet resultSet = statement.getResultSet();
130		CsvDriver.writeToCsv(resultSet, System.out, writeHeaderLine);
131
132		/*
133		* No header line for second, third, ... queries, so that
134		* output of several SQL queries can be concatenated.
135		*/
136		writeHeaderLine = false;
	122	/*
	123	* No header line for second, third, ... queries, so that
	124	* output of several SQL queries can be concatenated.
	125	*/
	126	writeHeaderLine = false;
137	127
138		while (statement.getMoreResults())
	128	while (statement.getMoreResults())
	129	{
	130	resultSet = statement.getResultSet();
	131	CsvDriver.writeToCsv(resultSet, System.out, writeHeaderLine);
	132	}
	133	}
	134
	135	if (argIndex < args.length)
139	136	{
140		resultSet = statement.getResultSet();
141		CsvDriver.writeToCsv(resultSet, System.out, writeHeaderLine);
	137	reader = new BufferedReader(new FileReader(args[argIndex]));
	138	argIndex++;
142	139	}
143	140	}
144
145		if (argIndex < args.length)
146		{
147		reader = new BufferedReader(new FileReader(args[argIndex]));
148		argIndex++;
149		}
	141	while (reader != null);
150	142	}
151		while (reader != null);
152	143	}
153	144	else
154	145	{

161	152	e.printStackTrace();
162	153	exitStatus = -1;
163	154	}
164		finally
165		{
166		try
167		{
168		if (connection != null)
169		connection.close();
170		}
171		catch (SQLException e)
172		{
173		}
174		}
175	155	System.exit(exitStatus);
176	156	}
177	157	}

-1

src/main/java/org/relique/jdbc/csv/CsvPreparedStatement.java less more

366	366	checkOpen();
367	367	checkParameterIndex(parameterIndex);
368	368
369		this.parameters[parameterIndex] = new Double(x);
	369	this.parameters[parameterIndex] = Double.valueOf(x);
370	370
371	371	}
372	372

-8

src/main/java/org/relique/jdbc/csv/CsvResultSet.java less more

40	40	import java.sql.Time;
41	41	import java.sql.Timestamp;
42	42	import java.util.ArrayList;
43		import java.util.Arrays;
44	43	import java.util.Calendar;
45	44	import java.util.Comparator;
46	45	import java.util.HashMap;

140	139	*/
141	140	public class OrderByComparator implements Comparator<Map<String, Object>>
142	141	{
	142	@Override
143	143	public int compare(Map<String, Object> recordEnvironment1, Map<String, Object> recordEnvironment2)
144	144	{
145	145	int retval = 0;

256	256	String timestampFormat = ((CsvConnection)statement.getConnection()).getTimestampFormat();
257	257	String timeZone = ((CsvConnection)statement.getConnection()).getTimeZoneName();
258	258	Locale locale = ((CsvConnection)statement.getConnection()).getLocale();
259		this.converter = new StringConverter(dateFormat, timeFormat, timestampFormat, timeZone, locale);
	259	boolean useDateTimeFormatter = ((CsvConnection)statement.getConnection()).getUseDateTimeFormatter();
	260	this.converter = new StringConverter(dateFormat, timeFormat, timestampFormat, timeZone, locale, useDateTimeFormatter);
260	261	if (reader instanceof CsvReader)
261	262	{
262	263	((CsvReader) reader).setConverter(converter);

841	842
842	843	private void sortRows(int sqlOffset) throws SQLException
843	844	{
844		Map<String, Object> []allRows = new Map[bufferedRecordEnvironments.size()];
845		for (int i = 0; i < allRows.length; i++)
846		allRows[i] = bufferedRecordEnvironments.get(i);
	845	ArrayList<Map<String, Object>> allRows = new ArrayList<Map<String, Object>>(bufferedRecordEnvironments);
847	846	bufferedRecordEnvironments.clear();
848	847	try
849	848	{
850		Arrays.sort(allRows, new OrderByComparator());
	849	allRows.sort(new OrderByComparator());
851	850	}
852	851	catch (OrderByException e)
853	852	{
854	853	throw new SQLException(e.getMessage());
855	854	}
856		int rowLimit = allRows.length;
	855	int rowLimit = allRows.size();
857	856	if (maxRows != 0 && maxRows < rowLimit)
858	857	rowLimit = maxRows;
859	858	if (limit >= 0 && sqlOffset + limit < rowLimit)
860	859	rowLimit = sqlOffset + limit;
861	860
862	861	for (int i = sqlOffset; i < rowLimit; i++)
863		bufferedRecordEnvironments.add(allRows[i]);
	862	bufferedRecordEnvironments.add(allRows.get(i));
864	863	}
865	864
866	865	private void checkOpen() throws SQLException

2784	2783	// TODO Auto-generated method stub
2785	2784	}
2786	2785
	2786	@Override
2787	2787	public <T> T getObject(String columnLabel, Class<T> type) throws SQLException
2788	2788	{
2789	2789	throw new UnsupportedOperationException(CsvResources.getString("methodNotSupported") +
2790	2790	": ResultSet.getObject(String, Class<T>)");
2791	2791	}
2792	2792
	2793	@Override
2793	2794	public <T> T getObject(int columnIndex, Class<T> type) throws SQLException
2794	2795	{
2795	2796	throw new UnsupportedOperationException(CsvResources.getString("methodNotSupported") +

+16

-16

src/main/java/org/relique/jdbc/csv/CsvResultSetMetaData.java less more

162	162	private static final long serialVersionUID = -8819579540085202365L;
163	163
164	164	{
165		put("String", new Integer(Types.VARCHAR));
166		put("Boolean", new Integer(Types.BOOLEAN));
167		put("Byte", new Integer(Types.TINYINT));
168		put("Short", new Integer(Types.SMALLINT));
169		put("Int", new Integer(Types.INTEGER));
170		put("Integer", new Integer(Types.INTEGER));
171		put("Long", new Integer(Types.BIGINT));
172		put("Float", new Integer(Types.FLOAT));
173		put("Double", new Integer(Types.DOUBLE));
174		put("BigDecimal", new Integer(Types.DECIMAL));
175		put("Date", new Integer(Types.DATE));
176		put("Time", new Integer(Types.TIME));
177		put("Timestamp", new Integer(Types.TIMESTAMP));
178		put("Blob", new Integer(Types.BLOB));
179		put("Clob", new Integer(Types.CLOB));
180		put("expression", new Integer(Types.BLOB));
	165	put("String", Integer.valueOf(Types.VARCHAR));
	166	put("Boolean", Integer.valueOf(Types.BOOLEAN));
	167	put("Byte", Integer.valueOf(Types.TINYINT));
	168	put("Short", Integer.valueOf(Types.SMALLINT));
	169	put("Int", Integer.valueOf(Types.INTEGER));
	170	put("Integer", Integer.valueOf(Types.INTEGER));
	171	put("Long", Integer.valueOf(Types.BIGINT));
	172	put("Float", Integer.valueOf(Types.FLOAT));
	173	put("Double", Integer.valueOf(Types.DOUBLE));
	174	put("BigDecimal", Integer.valueOf(Types.DECIMAL));
	175	put("Date", Integer.valueOf(Types.DATE));
	176	put("Time", Integer.valueOf(Types.TIME));
	177	put("Timestamp", Integer.valueOf(Types.TIMESTAMP));
	178	put("Blob", Integer.valueOf(Types.BLOB));
	179	put("Clob", Integer.valueOf(Types.CLOB));
	180	put("expression", Integer.valueOf(Types.BLOB));
181	181	}
182	182	};
183	183

-1

src/main/java/org/relique/jdbc/csv/CsvStatement.java less more

397	397	connection.isFileTailPrepend(),
398	398	connection.isSuppressHeaders(),
399	399	filter,
400		connection.getSkipLeadingDataLines() + connection.getTransposedLines());
	400	connection.getSkipLeadingDataLines() + connection.getTransposedLines(),
	401	connection.getCharset());
401	402	}
402	403	else if (filter == null)
403	404	{

750	751	return null;
751	752	}
752	753
	754	@Override
753	755	public boolean isCloseOnCompletion() throws SQLException
754	756	{
755	757	checkOpen();

757	759	return false;
758	760	}
759	761
	762	@Override
760	763	public void closeOnCompletion() throws SQLException
761	764	{
762	765	throw new UnsupportedOperationException(CsvResources.getString("methodNotSupported") +

-0

src/main/java/org/relique/jdbc/csv/CurrentDateConstant.java less more

29	29	{
30	30	this.parent = parent;
31	31	}
	32	@Override
32	33	public Object eval(Map<String, Object> env)
33	34	{
34	35	return parent.getCurrentDate();
35	36	}
	37	@Override
36	38	public String toString()
37	39	{
38	40	return "CURRENT_DATE";
39	41	}
	42	@Override
40	43	public List<String> usedColumns(Set<String> availableColumns)
41	44	{
42	45	return new LinkedList<String>();

-0

src/main/java/org/relique/jdbc/csv/CurrentTimeConstant.java less more

29	29	{
30	30	this.parent = parent;
31	31	}
	32	@Override
32	33	public Object eval(Map<String, Object> env)
33	34	{
34	35	return parent.getCurrentTime();
35	36	}
	37	@Override
36	38	public String toString()
37	39	{
38	40	return "CURRENT_TIME";
39	41	}
	42	@Override
40	43	public List<String> usedColumns(Set<String> availableColumns)
41	44	{
42	45	return new LinkedList<String>();

-0

src/main/java/org/relique/jdbc/csv/ExistsExpression.java less more

30	30	{
31	31	this.subQuery = subQuery;
32	32	}
	33	@Override
33	34	public Boolean isTrue(Map<String, Object> env) throws SQLException
34	35	{
35	36	boolean matches = subQuery.evalList(env, new ExistsExpressionSubQueryRowMatcher());
36	37	return Boolean.valueOf(matches);
37	38	}
	39	@Override
38	40	public String toString()
39	41	{
40	42	StringBuilder sb = new StringBuilder();

42	44	sb.append(subQuery.toString());
43	45	return sb.toString();
44	46	}
	47	@Override
45	48	public List<String> usedColumns(Set<String> availableColumns)
46	49	{
47	50	return subQuery.usedColumns(availableColumns);
48	51	}
	52	@Override
49	53	public List<AggregateFunction> aggregateFunctions()
50	54	{
51	55	return subQuery.aggregateFunctions();

-0

src/main/java/org/relique/jdbc/csv/ExistsExpressionSubQueryRowMatcher.java less more

21	21
22	22	public class ExistsExpressionSubQueryRowMatcher implements SubQueryRowMatcher
23	23	{
	24	@Override
24	25	public boolean matches(Object expr) throws SQLException
25	26	{
26	27	/*

-0

src/main/java/org/relique/jdbc/csv/InExpression.java less more

39	39	this.obj = obj;
40	40	this.subQuery = subQuery;
41	41	}
	42	@Override
42	43	public Boolean isTrue(Map<String, Object> env) throws SQLException
43	44	{
44	45	Comparable objValue = (Comparable)obj.eval(env);

61	62	}
62	63	return Boolean.FALSE;
63	64	}
	65	@Override
64	66	public String toString()
65	67	{
66	68	StringBuilder sb = new StringBuilder();

85	87	}
86	88	return sb.toString();
87	89	}
	90	@Override
88	91	public List<String> usedColumns(Set<String> availableColumns)
89	92	{
90	93	List<String> result = new LinkedList<String>();

102	105	}
103	106	return result;
104	107	}
	108	@Override
105	109	public List<AggregateFunction> aggregateFunctions()
106	110	{
107	111	List<AggregateFunction> result = new LinkedList<AggregateFunction>();

-0

src/main/java/org/relique/jdbc/csv/InExpressionSubQueryRowMatcher.java less more

31	31	this.objValue = objValue;
32	32	}
33	33
	34	@Override
34	35	public boolean matches(Object expr) throws SQLException
35	36	{
36	37	/*

-0

src/main/java/org/relique/jdbc/csv/IsNullExpression.java less more

30	30	{
31	31	this.arg = arg;
32	32	}
	33	@Override
33	34	public Boolean isTrue(Map<String, Object> env) throws SQLException
34	35	{
35	36	Object o = arg.eval(env);

38	39	else
39	40	return Boolean.FALSE;
40	41	}
	42	@Override
41	43	public String toString()
42	44	{
43	45	return "N "+arg;
44	46	}
	47	@Override
45	48	public List<String> usedColumns(Set<String> availableColumns)
46	49	{
47	50	List<String> result = new LinkedList<String>();
48	51	result.addAll(arg.usedColumns(availableColumns));
49	52	return result;
50	53	}
	54	@Override
51	55	public List<AggregateFunction> aggregateFunctions()
52	56	{
53	57	List<AggregateFunction> result = new LinkedList<AggregateFunction>();

-0

src/main/java/org/relique/jdbc/csv/LikeExpression.java less more

33	33	this.arg2 = arg2;
34	34	this.escapeArg = escapeArg;
35	35	}
	36	@Override
36	37	public Boolean isTrue(Map<String, Object> env) throws SQLException
37	38	{
38	39	Object left = arg1.eval(env);

56	57	result = Boolean.valueOf(LikePattern.matches(right.toString(), escape, left.toString()));
57	58	return result;
58	59	}
	60	@Override
59	61	public String toString()
60	62	{
61	63	StringBuilder sb = new StringBuilder();

70	72	}
71	73	return sb.toString();
72	74	}
	75	@Override
73	76	public List<String> usedColumns(Set<String> availableColumns)
74	77	{
75	78	List<String> result = new LinkedList<String>();

79	82	result.addAll(escapeArg.usedColumns(availableColumns));
80	83	return result;
81	84	}
	85	@Override
82	86	public List<AggregateFunction> aggregateFunctions()
83	87	{
84	88	List<AggregateFunction> result = new LinkedList<AggregateFunction>();

-0

src/main/java/org/relique/jdbc/csv/MinimumMemoryMap.java less more

75	75
76	76	private class KeyHashCodeComparator implements Comparator<K>
77	77	{
	78	@Override
78	79	public int compare(K key1, K key2)
79	80	{
80	81	int hashCode1 = (key1 != null) ? key1.hashCode() : 0;

-0

src/main/java/org/relique/jdbc/csv/NotExpression.java less more

35	35	isValid = this.content.isValid();
36	36	}
37	37	}
	38	@Override
38	39	public boolean isValid()
39	40	{
40	41	return isValid;
41	42	}
	43	@Override
42	44	public Boolean isTrue(Map<String, Object> env) throws SQLException
43	45	{
44	46	Boolean b = content.isTrue(env);

49	51	else
50	52	return Boolean.TRUE;
51	53	}
	54	@Override
52	55	public String toString()
53	56	{
54	57	return "NOT "+content;
55	58	}
	59	@Override
56	60	public List<String> usedColumns(Set<String> availableColumns)
57	61	{
58	62	return content.usedColumns(availableColumns);
59	63	}
	64	@Override
60	65	public List<AggregateFunction> aggregateFunctions()
61	66	{
62	67	return content.aggregateFunctions();

-0

src/main/java/org/relique/jdbc/csv/NullConstant.java less more

24	24
25	25	class NullConstant extends Expression
26	26	{
	27	@Override
27	28	public Object eval(Map<String, Object> env)
28	29	{
29	30	return null;
30	31	}
	32	@Override
31	33	public String toString()
32	34	{
33	35	return "null";
34	36	}
	37	@Override
35	38	public List<String> usedColumns(Set<String> availableColumns)
36	39	{
37	40	return new LinkedList<String>();

-0

src/main/java/org/relique/jdbc/csv/NumericConstant.java less more

29	29	{
30	30	value = d;
31	31	}
	32	@Override
32	33	public Object eval(Map<String, Object> env)
33	34	{
34	35	return value;
35	36	}
	37	@Override
36	38	public String toString()
37	39	{
38	40	return value.toString();
39	41	}
	42	@Override
40	43	public List<String> usedColumns(Set<String> availableColumns)
41	44	{
42	45	return new LinkedList<String>();

-0

src/main/java/org/relique/jdbc/csv/OrExpression.java less more

37	37	isValid = left.isValid() && right.isValid();
38	38	}
39	39	}
	40	@Override
40	41	public boolean isValid()
41	42	{
42	43	return isValid;
43	44	}
	45	@Override
44	46	public Boolean isTrue(Map<String, Object> env) throws SQLException
45	47	{
46	48	Boolean leftIsTrue = left.isTrue(env);

60	62	return Boolean.FALSE;
61	63	}
62	64	}
	65	@Override
63	66	public String toString()
64	67	{
65	68	return "OR "+left+" "+right;
66	69	}
	70	@Override
67	71	public List<String> usedColumns(Set<String> availableColumns)
68	72	{
69	73	List<String> result = new LinkedList<String>();

71	75	result.addAll(right.usedColumns(availableColumns));
72	76	return result;
73	77	}
	78	@Override
74	79	public List<AggregateFunction> aggregateFunctions()
75	80	{
76	81	List<AggregateFunction> result = new LinkedList<AggregateFunction>();

-0

src/main/java/org/relique/jdbc/csv/OrderByEntry.java less more

27	27	this.expression = expression;
28	28	}
29	29
	30	@Override
30	31	public String toString()
31	32	{
32	33	return expression.toString() + " " + order;

-0

src/main/java/org/relique/jdbc/csv/ParsedExpression.java less more

32	32	content = left;
33	33	placeholders = new HashMap<String, Object>();
34	34	}
	35	@Override
35	36	public boolean isValid()
36	37	{
37	38	return content.isValid();
38	39	}
	40	@Override
39	41	public Boolean isTrue(Map<String, Object> env) throws SQLException
40	42	{
41	43	if(!placeholders.isEmpty())

50	52	}
51	53	return ((LogicalExpression)content).isTrue(env);
52	54	}
	55	@Override
53	56	public Object eval(Map<String, Object> env) throws SQLException
54	57	{
55	58	if(!placeholders.isEmpty())

64	67	}
65	68	return content.eval(env);
66	69	}
	70	@Override
67	71	public String toString()
68	72	{
69	73	return content.toString();
70	74	}
	75	@Override
71	76	public List<String> usedColumns(Set<String> availableColumns)
72	77	{
73	78	return content.usedColumns(availableColumns);
74	79	}
	80	@Override
75	81	public List<AggregateFunction> aggregateFunctions()
76	82	{
77	83	return content.aggregateFunctions();
78	84	}
	85	@Override
79	86	public void resetAggregateFunctions()
80	87	{
81	88	content.resetAggregateFunctions();

-0

src/main/java/org/relique/jdbc/csv/ParsedStatement.java less more

51	51	this.offset = offset;
52	52	}
53	53
	54	@Override
54	55	public String toString()
55	56	{
56	57	StringBuilder sb = new StringBuilder();

-0

src/main/java/org/relique/jdbc/csv/Placeholder.java less more

34	34	index = nextIndex;
35	35	nextIndex++;
36	36	}
	37	@Override
37	38	public Object eval(Map<String, Object> env)
38	39	{
39	40	return env.get("?" + index);
40	41	}
	42	@Override
41	43	public String toString()
42	44	{
43	45	return "?";
44	46	}
	47	@Override
45	48	public List<String> usedColumns(Set<String> availableColumns)
46	49	{
47	50	return new LinkedList<String>();

-0

src/main/java/org/relique/jdbc/csv/QueryEnvEntry.java less more

41	41	return key;
42	42	}
43	43
	44	@Override
44	45	public Object eval(Map<String, Object> env) throws SQLException
45	46	{
46	47	return expression.eval(env);
47	48	}
48	49
	50	@Override
49	51	public String toString()
50	52	{
51	53	return key+": "+expression.toString();
52	54	}
53	55
	56	@Override
54	57	public void resetAggregateFunctions()
55	58	{
56	59	expression.resetAggregateFunctions();

+15

-10

src/main/java/org/relique/jdbc/csv/RelopExpression.java less more

38	38	this.left = left;
39	39	this.right = right;
40	40	}
	41	@Override
41	42	public Boolean isTrue(Map<String, Object> env) throws SQLException
42	43	{
43	44	Boolean result = null;

84	85	try
85	86	{
86	87	if (leftValue != null && rightValue != null)
87		leftComparedToRightObj = new Integer(leftValue.compareTo(rightValue));
	88	leftComparedToRightObj = Integer.valueOf(leftValue.compareTo(rightValue));
88	89	}
89	90	catch (ClassCastException e)
90	91	{

105	106	StringConverter sc = (StringConverter) stringConverter.eval(env);
106	107	Date date = sc.parseDate(rightValue.toString());
107	108	if (date != null)
108		leftComparedToRightObj = new Integer(leftValue.compareTo(date));
	109	leftComparedToRightObj = Integer.valueOf(leftValue.compareTo(date));
109	110	}
110	111	else if (rightValue instanceof Date)
111	112	{

113	114	StringConverter sc = (StringConverter) stringConverter.eval(env);
114	115	Date date = sc.parseDate(leftValue.toString());
115	116	if (date != null)
116		leftComparedToRightObj = new Integer(date.compareTo((Date)rightValue));
	117	leftComparedToRightObj = Integer.valueOf(date.compareTo((Date)rightValue));
117	118	}
118	119	else if (leftValue instanceof Time)
119	120	{

121	122	StringConverter sc = (StringConverter) stringConverter.eval(env);
122	123	Time time = sc.parseTime(rightValue.toString());
123	124	if (time != null)
124		leftComparedToRightObj = new Integer(leftValue.compareTo(time));
	125	leftComparedToRightObj = Integer.valueOf(leftValue.compareTo(time));
125	126	}
126	127	else if (rightValue instanceof Time)
127	128	{

129	130	StringConverter sc = (StringConverter) stringConverter.eval(env);
130	131	Time time = sc.parseTime(leftValue.toString());
131	132	if (time != null)
132		leftComparedToRightObj = new Integer(time.compareTo((Time)rightValue));
	133	leftComparedToRightObj = Integer.valueOf(time.compareTo((Time)rightValue));
133	134	}
134	135	else if (leftValue instanceof Timestamp)
135	136	{

137	138	StringConverter sc = (StringConverter) stringConverter.eval(env);
138	139	Timestamp timestamp = sc.parseTimestamp(rightValue.toString());
139	140	if (timestamp != null)
140		leftComparedToRightObj = new Integer(leftValue.compareTo(timestamp));
	141	leftComparedToRightObj = Integer.valueOf(leftValue.compareTo(timestamp));
141	142	}
142	143	else if (rightValue instanceof Timestamp)
143	144	{

145	146	StringConverter sc = (StringConverter) stringConverter.eval(env);
146	147	Timestamp timestamp = sc.parseTimestamp(leftValue.toString());
147	148	if (timestamp != null)
148		leftComparedToRightObj = new Integer(timestamp.compareTo((Timestamp)rightValue));
	149	leftComparedToRightObj = Integer.valueOf(timestamp.compareTo((Timestamp)rightValue));
149	150	}
150	151	else if (leftValue instanceof Boolean)
151	152	{

162	163	}
163	164	else
164	165	{
165		Double leftDouble = new Double(((Number)leftValue).toString());
166		Double rightDouble = new Double(((Number)rightValue).toString());
167		leftComparedToRightObj = new Integer(leftDouble.compareTo(rightDouble));
	166	Double leftDouble = Double.valueOf(((Number)leftValue).toString());
	167	Double rightDouble = Double.valueOf(((Number)rightValue).toString());
	168	leftComparedToRightObj = Integer.valueOf(leftDouble.compareTo(rightDouble));
168	169	}
169	170	}
170	171	}

176	177	}
177	178	return leftComparedToRightObj;
178	179	}
	180	@Override
179	181	public String toString()
180	182	{
181	183	return op+" "+left+" "+right;
182	184	}
	185	@Override
183	186	public List<String> usedColumns(Set<String> availableColumns)
184	187	{
185	188	List<String> result = new LinkedList<String>();

187	190	result.addAll(right.usedColumns(availableColumns));
188	191	return result;
189	192	}
	193	@Override
190	194	public List<AggregateFunction> aggregateFunctions()
191	195	{
192	196	List<AggregateFunction> result = new LinkedList<AggregateFunction>();

194	198	result.addAll(right.aggregateFunctions());
195	199	return result;
196	200	}
	201	@Override
197	202	public boolean isValid()
198	203	{
199	204	return isValid;

-2

src/main/java/org/relique/jdbc/csv/SQLAbsFunction.java less more

30	30	{
31	31	this.expression = expression;
32	32	}
	33	@Override
33	34	public Object eval(Map<String, Object> env) throws SQLException
34	35	{
35	36	Object retval = null;

40	41	{
41	42	try
42	43	{
43		o = new Double(o.toString());
	44	o = Double.valueOf(o.toString());
44	45	}
45	46	catch(NumberFormatException e)
46	47	{

76	77	double d = ((Number)o).doubleValue();
77	78	if (d < 0)
78	79	d = -d;
79		retval = new Double(d);
	80	retval = Double.valueOf(d);
80	81	}
81	82	}
82	83	}
83	84	return retval;
84	85	}
	86	@Override
85	87	public String toString()
86	88	{
87	89	return "ABS("+expression+")";
88	90	}
	91	@Override
89	92	public List<String> usedColumns(Set<String> availableColumns)
90	93	{
91	94	List<String> result = new LinkedList<String>();
92	95	result.addAll(expression.usedColumns(availableColumns));
93	96	return result;
94	97	}
	98	@Override
95	99	public List<AggregateFunction> aggregateFunctions()
96	100	{
97	101	List<AggregateFunction> result = new LinkedList<AggregateFunction>();

-1

src/main/java/org/relique/jdbc/csv/SQLAvgFunction.java less more

26	26	{
27	27	super(isDistinct, expression);
28	28	}
	29	@Override
29	30	public Object eval(Map<String, Object> env) throws SQLException
30	31	{
31	32	Object o = super.eval(env);
32	33	if (o != null)
33	34	{
34	35	double average = ((Number)o).doubleValue() / counter;
35		o = new Double(average);
	36	o = Double.valueOf(average);
36	37	}
37	38	return o;
38	39	}
	40	@Override
39	41	public String toString()
40	42	{
41	43	StringBuilder sb = new StringBuilder("AVG(");

-0

src/main/java/org/relique/jdbc/csv/SQLCalendarFunction.java less more

36	36	this.calendarField = calendarField;
37	37	this.expression = expression;
38	38	}
	39	@Override
39	40	public Object eval(Map<String, Object> env) throws SQLException
40	41	{
41	42	Object retval = null;

84	85	}
85	86	return retval;
86	87	}
	88	@Override
87	89	public String toString()
88	90	{
89	91	return functionName+"("+expression+")";
90	92	}
	93	@Override
91	94	public List<String> usedColumns(Set<String> availableColumns)
92	95	{
93	96	List<String> result = new LinkedList<String>();
94	97	result.addAll(expression.usedColumns(availableColumns));
95	98	return result;
96	99	}
	100	@Override
97	101	public List<AggregateFunction> aggregateFunctions()
98	102	{
99	103	List<AggregateFunction> result = new LinkedList<AggregateFunction>();

-0

src/main/java/org/relique/jdbc/csv/SQLCoalesceFunction.java less more

31	31	{
32	32	this.expressions = expressions;
33	33	}
	34	@Override
34	35	public Object eval(Map<String, Object> env) throws SQLException
35	36	{
36	37	Object retval = null;

46	47	}
47	48	return retval;
48	49	}
	50	@Override
49	51	public String toString()
50	52	{
51	53	StringBuilder sb = new StringBuilder("COALESCE(");

60	62	sb.append(")");
61	63	return sb.toString();
62	64	}
	65	@Override
63	66	public List<String> usedColumns(Set<String> availableColumns)
64	67	{
65	68	List<String> result = new LinkedList<String>();

70	73	}
71	74	return result;
72	75	}
	76	@Override
73	77	public List<AggregateFunction> aggregateFunctions()
74	78	{
75	79	List<AggregateFunction> result = new LinkedList<AggregateFunction>();

-0

src/main/java/org/relique/jdbc/csv/SQLCountFunction.java less more

35	35	this.distinctValues = new HashSet<Object>();
36	36	this.expression = expression;
37	37	}
	38	@Override
38	39	public Object eval(Map<String, Object> env) throws SQLException
39	40	{
40	41	Integer retval;

85	86	}
86	87	return retval;
87	88	}
	89	@Override
88	90	public String toString()
89	91	{
90	92	StringBuilder sb = new StringBuilder("COUNT(");

94	96	sb.append(")");
95	97	return sb.toString();
96	98	}
	99	@Override
97	100	public List<String> usedColumns(Set<String> availableColumns)
98	101	{
99	102	return new LinkedList<String>();
100	103	}
	104	@Override
101	105	public List<String> aggregateColumns(Set<String> availableColumns)
102	106	{
103	107	List<String> result = new LinkedList<String>();

105	109	result.addAll(expression.usedColumns(availableColumns));
106	110	return result;
107	111	}
	112	@Override
108	113	public List<AggregateFunction> aggregateFunctions()
109	114	{
110	115	List<AggregateFunction> result = new LinkedList<AggregateFunction>();
111	116	result.add(this);
112	117	return result;
113	118	}
	119	@Override
114	120	public void resetAggregateFunctions()
115	121	{
116	122	if (this.distinctValues != null)
117	123	this.distinctValues.clear();
118	124	this.counter = 0;
119	125	}
	126	@Override
120	127	public void processRow(Map<String, Object> env) throws SQLException
121	128	{
122	129	if (expression instanceof AsteriskExpression)

-0

src/main/java/org/relique/jdbc/csv/SQLLengthFunction.java less more

30	30	{
31	31	this.expression = expression;
32	32	}
	33	@Override
33	34	public Object eval(Map<String, Object> env) throws SQLException
34	35	{
35	36	Object retval = expression.eval(env);

37	38	retval = Integer.valueOf(retval.toString().length());
38	39	return retval;
39	40	}
	41	@Override
40	42	public String toString()
41	43	{
42	44	return "LENGTH("+expression+")";
43	45	}
	46	@Override
44	47	public List<String> usedColumns(Set<String> availableColumns)
45	48	{
46	49	List<String> result = new LinkedList<String>();
47	50	result.addAll(expression.usedColumns(availableColumns));
48	51	return result;
49	52	}
	53	@Override
50	54	public List<AggregateFunction> aggregateFunctions()
51	55	{
52	56	List<AggregateFunction> result = new LinkedList<AggregateFunction>();

-0

src/main/java/org/relique/jdbc/csv/SQLLowerFunction.java less more

30	30	{
31	31	this.expression = expression;
32	32	}
	33	@Override
33	34	public Object eval(Map<String, Object> env) throws SQLException
34	35	{
35	36	Object retval = expression.eval(env);

37	38	retval = retval.toString().toLowerCase();
38	39	return retval;
39	40	}
	41	@Override
40	42	public String toString()
41	43	{
42	44	return "LOWER("+expression+")";
43	45	}
	46	@Override
44	47	public List<String> usedColumns(Set<String> availableColumns)
45	48	{
46	49	List<String> result = new LinkedList<String>();
47	50	result.addAll(expression.usedColumns(availableColumns));
48	51	return result;
49	52	}
	53	@Override
50	54	public List<AggregateFunction> aggregateFunctions()
51	55	{
52	56	List<AggregateFunction> result = new LinkedList<AggregateFunction>();

-0

src/main/java/org/relique/jdbc/csv/SQLMaxFunction.java less more

33	33	this.isDistinct = isDistinct;
34	34	this.expression = expression;
35	35	}
	36	@Override
36	37	public Object eval(Map<String, Object> env) throws SQLException
37	38	{
38	39	Object o = env.get(GROUPING_COLUMN_NAME);

57	58	}
58	59	return max;
59	60	}
	61	@Override
60	62	public String toString()
61	63	{
62	64	StringBuilder sb = new StringBuilder("MAX(");

66	68	sb.append(")");
67	69	return sb.toString();
68	70	}
	71	@Override
69	72	public List<String> usedColumns(Set<String> availableColumns)
70	73	{
71	74	return new LinkedList<String>();
72	75	}
	76	@Override
73	77	public List<String> aggregateColumns(Set<String> availableColumns)
74	78	{
75	79	List<String> result = new LinkedList<String>();
76	80	result.addAll(expression.usedColumns(availableColumns));
77	81	return result;
78	82	}
	83	@Override
79	84	public List<AggregateFunction> aggregateFunctions()
80	85	{
81	86	List<AggregateFunction> result = new LinkedList<AggregateFunction>();
82	87	result.add(this);
83	88	return result;
84	89	}
	90	@Override
85	91	public void resetAggregateFunctions()
86	92	{
87	93	this.max = null;
88	94	}
	95	@Override
89	96	public void processRow(Map<String, Object> env) throws SQLException
90	97	{
91	98	/*

-0

src/main/java/org/relique/jdbc/csv/SQLMinFunction.java less more

33	33	this.isDistinct = isDistinct;
34	34	this.expression = expression;
35	35	}
	36	@Override
36	37	public Object eval(Map<String, Object> env) throws SQLException
37	38	{
38	39	Object o = env.get(GROUPING_COLUMN_NAME);

57	58	}
58	59	return min;
59	60	}
	61	@Override
60	62	public String toString()
61	63	{
62	64	StringBuilder sb = new StringBuilder("MIN(");

66	68	sb.append(")");
67	69	return sb.toString();
68	70	}
	71	@Override
69	72	public List<String> usedColumns(Set<String> availableColumns)
70	73	{
71	74	return new LinkedList<String>();
72	75	}
	76	@Override
73	77	public List<String> aggregateColumns(Set<String> availableColumns)
74	78	{
75	79	List<String> result = new LinkedList<String>();
76	80	result.addAll(expression.usedColumns(availableColumns));
77	81	return result;
78	82	}
	83	@Override
79	84	public List<AggregateFunction> aggregateFunctions()
80	85	{
81	86	List<AggregateFunction> result = new LinkedList<AggregateFunction>();
82	87	result.add(this);
83	88	return result;
84	89	}
	90	@Override
85	91	public void resetAggregateFunctions()
86	92	{
87	93	this.min = null;
88	94	}
	95	@Override
89	96	public void processRow(Map<String, Object> env) throws SQLException
90	97	{
91	98	/*

-0

src/main/java/org/relique/jdbc/csv/SQLNullIfFunction.java less more

32	32	this.expression1 = expression1;
33	33	this.expression2 = expression2;
34	34	}
	35	@Override
35	36	public Object eval(Map<String, Object> env) throws SQLException
36	37	{
37	38	Object retval;

45	46	retval = value1;
46	47	return retval;
47	48	}
	49	@Override
48	50	public String toString()
49	51	{
50	52	return "NULLIF("+expression1+","+expression2+")";
51	53	}
	54	@Override
52	55	public List<String> usedColumns(Set<String> availableColumns)
53	56	{
54	57	List<String> result = new LinkedList<String>();

56	59	result.addAll(expression2.usedColumns(availableColumns));
57	60	return result;
58	61	}
	62	@Override
59	63	public List<AggregateFunction> aggregateFunctions()
60	64	{
61	65	List<AggregateFunction> result = new LinkedList<AggregateFunction>();

-4

src/main/java/org/relique/jdbc/csv/SQLRoundFunction.java less more

30	30	{
31	31	this.expression = expression;
32	32	}
	33	@Override
33	34	public Object eval(Map<String, Object> env) throws SQLException
34	35	{
35	36	Object retval = expression.eval(env);

39	40	{
40	41	try
41	42	{
42		retval = new Double(retval.toString());
	43	retval = Double.valueOf(retval.toString());
43	44	}
44	45	catch(NumberFormatException e)
45	46	{

50	51	{
51	52	if (retval instanceof Short)
52	53	{
53		retval = new Integer(((Short)retval).intValue());
	54	retval = Integer.valueOf(((Short)retval).intValue());
54	55	}
55	56	else if (!(retval instanceof Integer \|\| retval instanceof Long))
56	57	{
57	58	double d = ((Number)retval).doubleValue();
58	59	if (d < Integer.MIN_VALUE \|\| d > Integer.MAX_VALUE)
59		retval = new Double(Math.round(d));
	60	retval = Double.valueOf(Math.round(d));
60	61	else
61		retval = new Integer((int)Math.round(d));
	62	retval = Integer.valueOf((int)Math.round(d));
62	63	}
63	64	}
64	65	}
65	66	return retval;
66	67	}
	68	@Override
67	69	public String toString()
68	70	{
69	71	return "ROUND("+expression+")";
70	72	}
	73	@Override
71	74	public List<String> usedColumns(Set<String> availableColumns)
72	75	{
73	76	List<String> result = new LinkedList<String>();
74	77	result.addAll(expression.usedColumns(availableColumns));
75	78	return result;
76	79	}
	80	@Override
77	81	public List<AggregateFunction> aggregateFunctions()
78	82	{
79	83	List<AggregateFunction> result = new LinkedList<AggregateFunction>();

-0

src/main/java/org/relique/jdbc/csv/SQLStringAggFunction.java less more

39	39	this.expression = expression;
40	40	this.delimiter = delimiter;
41	41	}
	42	@Override
42	43	public Object eval(Map<String, Object> env) throws SQLException
43	44	{
44	45	Object stringAggregation = null;

81	82	}
82	83	return stringAggregation;
83	84	}
	85	@Override
84	86	public String toString()
85	87	{
86	88	StringBuilder sb = new StringBuilder("STRING_AGG(");

92	94	sb.append(")");
93	95	return sb.toString();
94	96	}
	97	@Override
95	98	public List<String> usedColumns(Set<String> availableColumns)
96	99	{
97	100	List<String> result = new LinkedList<String>();
98	101	result.addAll(delimiter.usedColumns(availableColumns));
99	102	return result;
100	103	}
	104	@Override
101	105	public List<String> aggregateColumns(Set<String> availableColumns)
102	106	{
103	107	List<String> result = new LinkedList<String>();
104	108	result.addAll(expression.usedColumns(availableColumns));
105	109	return result;
106	110	}
	111	@Override
107	112	public List<AggregateFunction> aggregateFunctions()
108	113	{
109	114	List<AggregateFunction> result = new LinkedList<AggregateFunction>();
110	115	result.add(this);
111	116	return result;
112	117	}
	118	@Override
113	119	public void resetAggregateFunctions()
114	120	{
115	121	distinctAggregateValues.clear();
116	122	aggregateValues.clear();
117	123	}
	124	@Override
118	125	public void processRow(Map<String, Object> env) throws SQLException
119	126	{
120	127	/*

-0

src/main/java/org/relique/jdbc/csv/SQLSubstringFunction.java less more

36	36	this.len = len;
37	37	}
38	38
	39	@Override
39	40	public Object eval(Map<String, Object> env) throws SQLException
40	41	{
41	42	Object retval = null;

139	140	return retval;
140	141	}
141	142
	143	@Override
142	144	public String toString()
143	145	{
144	146	StringBuilder sb = new StringBuilder("SUBSTRING(");

153	155	sb.append(")");
154	156	return sb.toString();
155	157	}
	158	@Override
156	159	public List<String> usedColumns(Set<String> availableColumns)
157	160	{
158	161	List<String> result = new LinkedList<String>();

162	165	result.addAll(len.usedColumns(availableColumns));
163	166	return result;
164	167	}
	168	@Override
165	169	public List<AggregateFunction> aggregateFunctions()
166	170	{
167	171	List<AggregateFunction> result = new LinkedList<AggregateFunction>();

-0

src/main/java/org/relique/jdbc/csv/SQLSumFunction.java less more

37	37	this.distinctValues = new HashSet<Object>();
38	38	this.expression = expression;
39	39	}
	40	@Override
40	41	public Object eval(Map<String, Object> env) throws SQLException
41	42	{
42	43	Object retval = null;

136	137	}
137	138	return retval;
138	139	}
	140	@Override
139	141	public String toString()
140	142	{
141	143	StringBuilder sb = new StringBuilder("SUM(");

145	147	sb.append(")");
146	148	return sb.toString();
147	149	}
	150	@Override
148	151	public List<String> usedColumns(Set<String> availableColumns)
149	152	{
150	153	return new LinkedList<String>();
151	154	}
	155	@Override
152	156	public List<String> aggregateColumns(Set<String> availableColumns)
153	157	{
154	158	List<String> result = new LinkedList<String>();
155	159	result.addAll(expression.usedColumns(availableColumns));
156	160	return result;
157	161	}
	162	@Override
158	163	public List<AggregateFunction> aggregateFunctions()
159	164	{
160	165	List<AggregateFunction> result = new LinkedList<AggregateFunction>();
161	166	result.add(this);
162	167	return result;
163	168	}
	169	@Override
164	170	public void resetAggregateFunctions()
165	171	{
166	172	if (this.distinctValues != null)

168	174	this.sum = null;
169	175	this.counter = 0;
170	176	}
	177	@Override
171	178	public void processRow(Map<String, Object> env) throws SQLException
172	179	{
173	180	/*

-0

src/main/java/org/relique/jdbc/csv/SQLTrimFunction.java less more

37	37	this.trimChars = trimChars;
38	38	this.trimType = trimType;
39	39	}
	40	@Override
40	41	public Object eval(Map<String, Object> env) throws SQLException
41	42	{
42	43	Object retval = expression.eval(env);

100	101	}
101	102	return retval;
102	103	}
	104	@Override
103	105	public String toString()
104	106	{
105	107	if (trimType == Type.LEADING)

109	111	else
110	112	return "TRIM("+expression+")";
111	113	}
	114	@Override
112	115	public List<String> usedColumns(Set<String> availableColumns)
113	116	{
114	117	List<String> result = new LinkedList<String>();

117	120	result.addAll(trimChars.usedColumns(availableColumns));
118	121	return result;
119	122	}
	123	@Override
120	124	public List<AggregateFunction> aggregateFunctions()
121	125	{
122	126	List<AggregateFunction> result = new LinkedList<AggregateFunction>();

-0

src/main/java/org/relique/jdbc/csv/SQLUpperFunction.java less more

30	30	{
31	31	this.expression = expression;
32	32	}
	33	@Override
33	34	public Object eval(Map<String, Object> env) throws SQLException
34	35	{
35	36	Object retval = expression.eval(env);

37	38	retval = retval.toString().toUpperCase();
38	39	return retval;
39	40	}
	41	@Override
40	42	public String toString()
41	43	{
42	44	return "UPPER("+expression+")";
43	45	}
	46	@Override
44	47	public List<String> usedColumns(Set<String> availableColumns)
45	48	{
46	49	List<String> result = new LinkedList<String>();
47	50	result.addAll(expression.usedColumns(availableColumns));
48	51	return result;
49	52	}
	53	@Override
50	54	public List<AggregateFunction> aggregateFunctions()
51	55	{
52	56	List<AggregateFunction> result = new LinkedList<AggregateFunction>();

-0

src/main/java/org/relique/jdbc/csv/SQLUserFunction.java less more

37	37	this.expressions = expressions;
38	38	}
39	39
	40	@Override
40	41	public Object eval(Map<String, Object> env) throws SQLException
41	42	{
42	43	Object retval = null;

183	184	return sb.toString();
184	185	}
185	186
	187	@Override
186	188	public String toString()
187	189	{
188	190	StringBuilder sb = new StringBuilder();

198	200	sb.append(")");
199	201	return sb.toString();
200	202	}
	203	@Override
201	204	public List<String> usedColumns(Set<String> availableColumns)
202	205	{
203	206	List<String> result = new LinkedList<String>();

207	210	}
208	211	return result;
209	212	}
	213	@Override
210	214	public List<AggregateFunction> aggregateFunctions()
211	215	{
212	216	List<AggregateFunction> result = new LinkedList<AggregateFunction>();

-1

src/main/java/org/relique/jdbc/csv/SearchedCaseExpression.java less more

38	38	this.elseExpression = elseExpression;
39	39	}
40	40
	41	@Override
41	42	public Object eval(Map<String, Object> env) throws SQLException
42	43	{
43	44	for (int i = 0; i < conditions.size(); i++)

57	58	return null;
58	59	}
59	60
	61	@Override
60	62	public String toString()
61	63	{
62	64	StringBuilder sb = new StringBuilder("CASE");

71	73	return sb.toString();
72	74	}
73	75
	76	@Override
74	77	public List<String> usedColumns(Set<String> availableColumns)
75	78	{
76	79	List<String> result = new LinkedList<String>();

88	91	result.addAll(elseExpression.usedColumns(availableColumns));
89	92	return result;
90	93	}
91
	94
	95	@Override
92	96	public List<AggregateFunction> aggregateFunctions()
93	97	{
94	98	List<AggregateFunction> result = new LinkedList<AggregateFunction>();

-1

src/main/java/org/relique/jdbc/csv/SimpleCaseExpression.java less more

40	40	this.elseExpression = elseExpression;
41	41	}
42	42
	43	@Override
43	44	public Object eval(Map<String, Object> env) throws SQLException
44	45	{
45	46	Object o1 = caseExpression.eval(env);

57	58	return null;
58	59	}
59	60
	61	@Override
60	62	public String toString()
61	63	{
62	64	StringBuilder sb = new StringBuilder("CASE ");

72	74	return sb.toString();
73	75	}
74	76
	77	@Override
75	78	public List<String> usedColumns(Set<String> availableColumns)
76	79	{
77	80	List<String> result = new LinkedList<String>();

90	93	result.addAll(elseExpression.usedColumns(availableColumns));
91	94	return result;
92	95	}
93
	96
	97	@Override
94	98	public List<AggregateFunction> aggregateFunctions()
95	99	{
96	100	List<AggregateFunction> result = new LinkedList<AggregateFunction>();

-0

src/main/java/org/relique/jdbc/csv/StringConstant.java less more

29	29	{
30	30	value = s;
31	31	}
	32	@Override
32	33	public Object eval(Map<String, Object> env)
33	34	{
34	35	return value;
35	36	}
	37	@Override
36	38	public String toString()
37	39	{
38	40	return "'"+value+"'";
39	41	}
	42	@Override
40	43	public List<String> usedColumns(Set<String> availableColumns)
41	44	{
42	45	return new LinkedList<String>();

+179

-97

src/main/java/org/relique/jdbc/csv/StringConverter.java less more

26	26	import java.text.DateFormatSymbols;
27	27	import java.text.ParseException;
28	28	import java.text.SimpleDateFormat;
	29	import java.time.LocalDate;
	30	import java.time.LocalDateTime;
	31	import java.time.LocalTime;
	32	import java.time.ZoneId;
	33	import java.time.ZonedDateTime;
	34	import java.time.format.DateTimeFormatter;
	35	import java.time.format.DateTimeFormatterBuilder;
29	36	import java.util.ArrayList;
30	37	import java.util.Calendar;
31	38	import java.util.GregorianCalendar;

54	61	private SimpleDateFormat simpleDateFormat;
55	62	private int currentYear;
56	63
	64	// Alternative Java 8 classes for parsing and formatting dates, times, timestamps.
	65	DateTimeFormatter dateFormatter;
	66	DateTimeFormatter timeFormatter;
	67	DateTimeFormatter timestampFormatter;
	68
57	69	public StringConverter(String dateformat, String timeformat, String timestampformat,
58		String timeZoneName)
59		{
60		init(dateformat, timeformat, timestampformat, timeZoneName, null);
	70	String timeZoneName, boolean useDateTimeFormatter)
	71	{
	72	init(dateformat, timeformat, timestampformat, timeZoneName, null, useDateTimeFormatter);
61	73	}
62	74
63	75	public StringConverter(String dateformat, String timeformat, String timestampformat,
64		String timeZoneName, Locale locale)
65		{
66		init(dateformat, timeformat, timestampformat, timeZoneName, locale);
	76	String timeZoneName, Locale locale, boolean useDateTimeFormatter)
	77	{
	78	init(dateformat, timeformat, timestampformat, timeZoneName, locale, useDateTimeFormatter);
67	79	}
68	80
69	81	private void init(String dateformat, String timeformat, String timestampformat,
70		String timeZoneName, Locale locale)
	82	String timeZoneName, Locale locale, boolean useDateTimeFormatter)
71	83	{
72	84	dateFormat = dateformat;
73	85	if (dateformat != null)
74	86	{
75		/*
76		* Can date be parsed with a simple regular expression, or is the full
77		* SimpleDateFormat parsing required?
78		*/
79		// TODO prefer to use SimpleDateFormat for everything but existing regex not 100% compatible
80		String upper = dateformat.toUpperCase(Locale.US);
81		boolean useSimpleDateFormat = false;
82		if (upper.contains("MMM"))
	87	if (useDateTimeFormatter)
	88	{
	89	dateFormatter = createFormatter(dateFormat, locale, timeZoneName);
	90	}
	91	else
83	92	{
84	93	/*
85		* Dates contain named months -- we need to use a SimpleDateFormat to parse them.
	94	* Can date be parsed with a simple regular expression, or is the full
	95	* SimpleDateFormat parsing required?
86	96	*/
87		useSimpleDateFormat = true;
88		}
89		else
90		{
91		for (int i = 0; i < upper.length(); i++)
92		{
93		char c = upper.charAt(i);
94		if (Character.isLetter(c) && c != 'D' && c != 'M' && c != 'Y')
	97	// TODO prefer to use SimpleDateFormat for everything but existing regex not 100% compatible
	98	String upper = dateformat.toUpperCase(Locale.US);
	99	boolean useSimpleDateFormat = false;
	100	if (upper.contains("MMM"))
	101	{
	102	/*
	103	* Dates contain named months -- we need to use a SimpleDateFormat to parse them.
	104	*/
	105	useSimpleDateFormat = true;
	106	}
	107	else
	108	{
	109	for (int i = 0; i < upper.length(); i++)
95	110	{
96		/*
97		* Dates are not just a straightforward format with days, months,
98		* years -- we need to use a SimpleDateFormat to parse them.
99		*/
100		useSimpleDateFormat = true;
	111	char c = upper.charAt(i);
	112	if (Character.isLetter(c) && c != 'D' && c != 'M' && c != 'Y')
	113	{
	114	/*
	115	* Dates are not just a straightforward format with days, months,
	116	* years -- we need to use a SimpleDateFormat to parse them.
	117	*/
	118	useSimpleDateFormat = true;
	119	}
101	120	}
102	121	}
103		}
104		if (useSimpleDateFormat)
105		{
106		/*
107		* Use Java API for parsing dates.
108		*/
109		if (locale != null)
110		{
111		DateFormatSymbols symbols = DateFormatSymbols.getInstance(locale);
112		simpleDateFormat = new SimpleDateFormat(dateformat, symbols);
113		}
114		else
115		{
116		simpleDateFormat = new SimpleDateFormat(dateformat);
	122	if (useSimpleDateFormat)
	123	{
	124	/*
	125	* Use Java API for parsing dates.
	126	*/
	127	if (locale != null)
	128	{
	129	DateFormatSymbols symbols = DateFormatSymbols.getInstance(locale);
	130	simpleDateFormat = new SimpleDateFormat(dateformat, symbols);
	131	}
	132	else
	133	{
	134	simpleDateFormat = new SimpleDateFormat(dateformat);
	135	}
117	136	}
118	137	}
119	138	}

122	141	* Use Java API for parsing times.
123	142	*/
124	143	timeFormat = timeformat;
	144	if (useDateTimeFormatter)
	145	{
	146	timeFormatter = createFormatter(timeFormat, locale, timeZoneName);
	147	}
	148	else
	149	{
	150	if (locale != null)
	151	{
	152	DateFormatSymbols symbols = DateFormatSymbols.getInstance(locale);
	153	simpleTimeFormat = new SimpleDateFormat(timeformat, symbols);
	154	}
	155	else
	156	{
	157	simpleTimeFormat = new SimpleDateFormat(timeformat);
	158	}
	159	}
	160
	161	if (useDateTimeFormatter)
	162	{
	163	if (timestampformat == null)
	164	timestampformat = "yyyy-MM-dd HH:mm:ss";
	165	timestampFormatter = createFormatter(timestampformat, locale, timeZoneName);
	166	}
	167	else
	168	{
	169	TimeZone timeZone = TimeZone.getTimeZone(timeZoneName);
	170	calendar = new GregorianCalendar();
	171	calendar.setTimeInMillis(System.currentTimeMillis());
	172	currentYear = calendar.get(Calendar.YEAR);
	173	calendar.clear();
	174	calendar.setTimeZone(timeZone);
	175	if (timestampformat != null && timestampformat.length() > 0)
	176	{
	177	/*
	178	* Use Java API for parsing dates and times.
	179	*/
	180	if (locale != null)
	181	{
	182	DateFormatSymbols symbols = DateFormatSymbols.getInstance(locale);
	183	timestampFormat = new SimpleDateFormat(timestampformat, symbols);
	184	}
	185	else
	186	{
	187	timestampFormat = new SimpleDateFormat(timestampformat);
	188	}
	189	timestampFormat.setTimeZone(timeZone);
	190	}
	191	else
	192	{
	193	/*
	194	* Parse timestamps using a fixed regular expression.
	195	*/
	196	timestampPattern = Pattern
	197	.compile("([0-9][0-9][0-9][0-9])-([0-9]?[0-9])-([0-9]?[0-9])[ T]([0-9]?[0-9]):([0-9]?[0-9]):([0-9]?[0-9]).*");
	198	}
	199	}
	200	}
	201
	202	private DateTimeFormatter createFormatter(String pattern, Locale locale, String timeZoneName)
	203	{
	204	DateTimeFormatter formatter;
	205	DateTimeFormatterBuilder builder = new DateTimeFormatterBuilder();
	206	builder.parseCaseInsensitive();
	207	builder.appendPattern(pattern);
125	208	if (locale != null)
126		{
127		DateFormatSymbols symbols = DateFormatSymbols.getInstance(locale);
128		simpleTimeFormat = new SimpleDateFormat(timeformat, symbols);
129		}
	209	formatter = builder.toFormatter(locale);
130	210	else
131		{
132		simpleTimeFormat = new SimpleDateFormat(timeformat);
133		}
134
135		TimeZone timeZone = TimeZone.getTimeZone(timeZoneName);
136		calendar = new GregorianCalendar();
137		calendar.setTimeInMillis(System.currentTimeMillis());
138		currentYear = calendar.get(Calendar.YEAR);
139		calendar.clear();
140		calendar.setTimeZone(timeZone);
141		if (timestampformat != null && timestampformat.length() > 0)
142		{
143		/*
144		* Use Java API for parsing dates and times.
145		*/
146		if (locale != null)
147		{
148		DateFormatSymbols symbols = DateFormatSymbols.getInstance(locale);
149		timestampFormat = new SimpleDateFormat(timestampformat, symbols);
150		}
151		else
152		{
153		timestampFormat = new SimpleDateFormat(timestampformat);
154		}
155		timestampFormat.setTimeZone(timeZone);
156		}
157		else
158		{
159		/*
160		* Parse timestamps using a fixed regular expression.
161		*/
162		timestampPattern = Pattern
163		.compile("([0-9][0-9][0-9][0-9])-([0-9]?[0-9])-([0-9]?[0-9])[ T]([0-9]?[0-9]):([0-9]?[0-9]):([0-9]?[0-9]).*");
164		}
165		}
166
	211	formatter = builder.toFormatter();
	212	return formatter.withZone(ZoneId.of(timeZoneName));
	213	}
	214
167	215	public String parseString(String str)
168	216	{
169	217	return str;

423	471	Date sqlResult = null;
424	472	if (str != null && str.length() > 0)
425	473	{
	474	if (dateFormatter != null)
	475	{
	476	LocalDate localDate = LocalDate.parse(str, dateFormatter);
	477	return Date.valueOf(localDate);
	478	}
426	479	if (simpleDateFormat != null)
427	480	{
428	481	java.util.Date parsedDate = simpleDateFormat.parse(str);

457	510
458	511	if (d != null)
459	512	{
460		if (simpleDateFormat != null)
	513	if (dateFormatter != null)
	514	{
	515	formatted = d.toLocalDate().format(dateFormatter);
	516	}
	517	else if (simpleDateFormat != null)
461	518	{
462	519	formatted = simpleDateFormat.format(d);
463	520	}

514	571	try
515	572	{
516	573	Time sqlResult = null;
517		if (str != null && str.length() > 0)
518		{
519		str = str.trim();
520		while (str.length() < timeFormat.length())
521		{
522		str = "0" + str;
523		}
524		java.util.Date parsedDate = simpleTimeFormat.parse(str);
525		long millis = parsedDate.getTime();
526		sqlResult = new Time(millis);
	574	if (timeFormatter != null)
	575	{
	576	LocalTime localTime = LocalTime.parse(str, timeFormatter);
	577	sqlResult = Time.valueOf(localTime);
	578	}
	579	else
	580	{
	581	if (str != null && str.length() > 0)
	582	{
	583	str = str.trim();
	584	while (str.length() < timeFormat.length())
	585	{
	586	str = "0" + str;
	587	}
	588	java.util.Date parsedDate = simpleTimeFormat.parse(str);
	589	long millis = parsedDate.getTime();
	590	sqlResult = new Time(millis);
	591	}
527	592	}
528	593	return sqlResult;
529	594	}

548	613
549	614	if (t != null)
550	615	{
551		formatted = simpleTimeFormat.format(t);
	616	if (timeFormatter != null)
	617	{
	618	formatted = t.toLocalTime().format(timeFormatter);
	619	}
	620	else
	621	{
	622	formatted = simpleTimeFormat.format(t);
	623	}
552	624	}
553	625	return formatted;
554	626	}

560	632	{
561	633	if (str != null && str.length() > 0)
562	634	{
563		if (timestampFormat != null)
	635	if (timestampFormatter != null)
	636	{
	637	ZonedDateTime zonedDateTime = ZonedDateTime.parse(str, timestampFormatter);
	638	result = Timestamp.from(zonedDateTime.toInstant());
	639	}
	640	else if (timestampFormat != null)
564	641	{
565	642	java.util.Date date = timestampFormat.parse(str);
566	643	result = new Timestamp(date.getTime());

602	679
603	680	if (timestamp != null)
604	681	{
605		if (timestampFormat != null)
	682	if (timestampFormatter != null)
	683	{
	684	LocalDateTime localDateTime = LocalDateTime.ofInstant(timestamp.toInstant(), timestampFormatter.getZone());
	685	formatted = localDateTime.format(timestampFormatter);
	686	}
	687	else if (timestampFormat != null)
606	688	{
607	689	formatted = timestampFormat.format(timestamp);
608	690	}

-0

src/main/java/org/relique/jdbc/csv/SubQueryEqualsRowMatcher.java less more

24	24	{
25	25	ArrayList<Object> values = new ArrayList<Object>();
26	26
	27	@Override
27	28	public boolean matches(Object expr) throws SQLException
28	29	{
29	30	/*

+18

-21

src/main/java/org/relique/jdbc/csv/SubQueryExpression.java less more

33	33	this.parsedStatement = parsedStatement;
34	34	}
35	35
	36	@Override
36	37	public Object eval(Map<String, Object> env) throws SQLException
37	38	{
38	39	/*

59	60	* SELECT ... WHERE EXISTS (SELECT X2 FROM ... )
60	61	*/
61	62	boolean matches = false;
62		CsvStatement statement = null;
63		ResultSet resultSet = null;
64	63
65		try
	64	/*
	65	* Clear query expressions so that any aggregate functions are calculated
	66	* independently each time this SQL statement is executed.
	67	*/
	68	SqlParser sqlParser = new SqlParser();
	69	for (ParsedExpression parsedExpr : parsedStatement.queryEntries)
66	70	{
67		/*
68		* Clear query expressions so that any aggregate functions are calculated
69		* independently each time this SQL statement is executed.
70		*/
71		SqlParser sqlParser = new SqlParser();
72		for (ParsedExpression parsedExpr : parsedStatement.queryEntries)
73		{
74		parsedExpr.resetAggregateFunctions();
75		}
	71	parsedExpr.resetAggregateFunctions();
	72	}
76	73
77		sqlParser.setParsedStatement(parsedStatement);
	74	sqlParser.setParsedStatement(parsedStatement);
78	75
79		Expression expr = new ColumnName(CsvStatement.STATEMENT_COLUMN_NAME);
80		statement = (CsvStatement) expr.eval(env);
	76	Expression expr = new ColumnName(CsvStatement.STATEMENT_COLUMN_NAME);
	77	CsvStatement statement = (CsvStatement) expr.eval(env);
81	78
82		resultSet = statement.executeParsedQuery(sqlParser, env);
	79	try (ResultSet resultSet = statement.executeParsedQuery(sqlParser, env))
	80	{
83	81	if (resultSet.getMetaData().getColumnCount() != 1)
84	82	throw new SQLException(CsvResources.getString("subqueryOneColumn"));
85	83

93	91	matches = rowMatcher.matches(o);
94	92	}
95	93	}
96		finally
97		{
98		if (resultSet != null)
99		resultSet.close();
100		}
	94
101	95	return matches;
102	96	}
	97	@Override
103	98	public String toString()
104	99	{
105	100	StringBuilder sb = new StringBuilder();

108	103	sb.append(")");
109	104	return sb.toString();
110	105	}
	106	@Override
111	107	public List<String> usedColumns(Set<String> availableColumns)
112	108	{
113	109	List<String> retval = new LinkedList<String>();

123	119	}
124	120	return retval;
125	121	}
	122	@Override
126	123	public List<AggregateFunction> aggregateFunctions()
127	124	{
128	125	/*

-0

src/main/java/org/relique/jdbc/dbf/DbfReader.java less more

114	114	dbfTypeToSQLType.put("FLOAT", "Double");
115	115	}
116	116
	117	@Override
117	118	public void close() throws SQLException
118	119	{
119	120	if (table != null)

130	131	table = null;
131	132	}
132	133
	134	@Override
133	135	public String[] getColumnNames() throws SQLException
134	136	{
135	137	if (columnNames == null)

172	174	}
173	175	}
174	176
	177	@Override
175	178	public boolean next() throws SQLException
176	179	{
177	180	rowNo++;

197	200	return true;
198	201	}
199	202
	203	@Override
200	204	public String[] getColumnTypes() throws SQLException
201	205	{
202	206	String[] result = new String[fields.size()];

218	222	return result;
219	223	}
220	224
	225	@Override
221	226	public int[] getColumnSizes() throws SQLException
222	227	{
223	228	int[] result = new int[fields.size()];

236	241	return result;
237	242	}
238	243
	244	@Override
239	245	public Map<String, Object> getEnvironment() throws SQLException
240	246	{
241	247	int initialSize = fields.size() * 2;

276	282	return result;
277	283	}
278	284
	285	@Override
279	286	public String getTableAlias()
280	287	{
281	288	return tableAlias;

-2

src/main/javacc/org/relique/jdbc/csv/where.jj less more

1138	1138	}
1139	1139	try
1140	1140	{
1141		value = new Long(digits);
	1141	value = Long.valueOf(digits);
1142	1142	if (isLong == false && value.longValue() >= Integer.MIN_VALUE && value.longValue() <= Integer.MAX_VALUE)
1143	1143	value = Integer.valueOf(value.intValue());
1144	1144	}
1145	1145	catch (NumberFormatException e)
1146	1146	{
1147		value = new Double(digits);
	1147	value = Double.valueOf(digits);
1148	1148	}
1149	1149	return new NumericConstant(value);
1150	1150	}

+232

-311

src/test/java/org/relique/jdbc/csv/TestAggregateFunctions.java less more

69	69	@Test
70	70	public void testCountStar() throws SQLException
71	71	{
72		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath);
73
74		Statement stmt = conn.createStatement();
75
76		ResultSet results = stmt.executeQuery("SELECT COUNT(*) FROM sample");
77		assertTrue(results.next());
78		assertEquals("Incorrect count", 6, results.getInt(1));
79		assertFalse(results.next());
80
81		results.close();
82		stmt.close();
83		conn.close();
	72	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath);
	73	Statement stmt = conn.createStatement();
	74	ResultSet results = stmt.executeQuery("SELECT COUNT(*) FROM sample"))
	75	{
	76	assertTrue(results.next());
	77	assertEquals("Incorrect count", 6, results.getInt(1));
	78	assertFalse(results.next());
	79	}
84	80	}
85	81
86	82	@Test
87	83	public void testCountColumn() throws SQLException
88	84	{
89		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath);
90
91		Statement stmt = conn.createStatement();
92
93		ResultSet results = stmt.executeQuery("SELECT count(ID) FROM sample");
94		assertTrue(results.next());
95		assertEquals("Incorrect count", "6", results.getString(1));
96		assertFalse(results.next());
97
98		results.close();
99		stmt.close();
100		conn.close();
	85	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath);
	86	Statement stmt = conn.createStatement();
	87	ResultSet results = stmt.executeQuery("SELECT count(ID) FROM sample"))
	88	{
	89	assertTrue(results.next());
	90	assertEquals("Incorrect count", "6", results.getString(1));
	91	assertFalse(results.next());
	92	}
101	93	}
102	94
103	95	@Test
104	96	public void testCountInvalidColumn() throws SQLException
105	97	{
106		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath);
107
108		Statement stmt = conn.createStatement();
109
110		try
111		{
112		stmt.executeQuery("SELECT count(XXXX) FROM sample");
113		fail("Should raise a java.sqlSQLException");
114		}
115		catch (SQLException e)
116		{
117		assertEquals("java.sql.SQLException: " + CsvResources.getString("invalidColumnName") + ": XXXX", "" + e);
	98	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath);
	99	Statement stmt = conn.createStatement())
	100	{
	101	try
	102	{
	103	stmt.executeQuery("SELECT count(XXXX) FROM sample");
	104	fail("Should raise a java.sqlSQLException");
	105	}
	106	catch (SQLException e)
	107	{
	108	assertEquals("java.sql.SQLException: " + CsvResources.getString("invalidColumnName") + ": XXXX", "" + e);
	109	}
118	110	}
119	111	}
120	112
121	113	@Test
122	114	public void testCountPlusColumn() throws SQLException
123	115	{
124		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath);
125
126		Statement stmt = conn.createStatement();
127
128		try
129		{
130		stmt.executeQuery("SELECT ID, count(ID) FROM sample");
131		fail("Should raise a java.sqlSQLException");
132		}
133		catch (SQLException e)
134		{
135		assertEquals("java.sql.SQLException: " + CsvResources.getString("columnsWithAggregateFunctions"), "" + e);
	116	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath);
	117	Statement stmt = conn.createStatement())
	118	{
	119	try
	120	{
	121	stmt.executeQuery("SELECT ID, count(ID) FROM sample");
	122	fail("Should raise a java.sqlSQLException");
	123	}
	124	catch (SQLException e)
	125	{
	126	assertEquals("java.sql.SQLException: " + CsvResources.getString("columnsWithAggregateFunctions"), "" + e);
	127	}
136	128	}
137	129	}
138	130
139	131	@Test
140	132	public void testCountWhere() throws SQLException
141	133	{
142		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath);
143
144		Statement stmt = conn.createStatement();
145
146		ResultSet results = stmt.executeQuery("SELECT count(*) C FROM sample where ID like '%234'");
147		assertTrue(results.next());
148		assertEquals("Incorrect count", 2, results.getInt("C"));
149		assertFalse(results.next());
150
151		results.close();
152		stmt.close();
153		conn.close();
	134	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath);
	135	Statement stmt = conn.createStatement();
	136	ResultSet results = stmt.executeQuery("SELECT count(*) C FROM sample where ID like '%234'"))
	137	{
	138	assertTrue(results.next());
	139	assertEquals("Incorrect count", 2, results.getInt("C"));
	140	assertFalse(results.next());
	141	}
154	142	}
155	143
156	144	@Test
157	145	public void testCountNoResults() throws SQLException
158	146	{
159		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath);
160
161		Statement stmt = conn.createStatement();
162
163		ResultSet results = stmt.executeQuery("SELECT count(*) FROM sample where ID like 'ZZZ%'");
164		assertTrue(results.next());
165		assertEquals("Incorrect count", 0, results.getInt(1));
166		assertFalse(results.next());
167
168		results.close();
169		stmt.close();
170		conn.close();
	147	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath);
	148	Statement stmt = conn.createStatement();
	149	ResultSet results = stmt.executeQuery("SELECT count(*) FROM sample where ID like 'ZZZ%'"))
	150	{
	151	assertTrue(results.next());
	152	assertEquals("Incorrect count", 0, results.getInt(1));
	153	assertFalse(results.next());
	154	}
171	155	}
172	156
173	157	@Test
174	158	public void testCountInWhereClause() throws SQLException
175	159	{
176		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath);
177
178		Statement stmt = conn.createStatement();
179
180		try
181		{
182		stmt.executeQuery("SELECT * FROM sample where count(*)=1");
183		fail("Should raise a java.sqlSQLException");
184		}
185		catch (SQLException e)
186		{
187		assertEquals("java.sql.SQLException: " + CsvResources.getString("noAggregateFunctions"), "" + e);
	160	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath);
	161	Statement stmt = conn.createStatement())
	162	{
	163	try
	164	{
	165	stmt.executeQuery("SELECT * FROM sample where count(*)=1");
	166	fail("Should raise a java.sqlSQLException");
	167	}
	168	catch (SQLException e)
	169	{
	170	assertEquals("java.sql.SQLException: " + CsvResources.getString("noAggregateFunctions"), "" + e);
	171	}
188	172	}
189	173	}
190	174

193	177	{
194	178	Properties props = new Properties();
195	179	props.put("columnTypes", "Int,String,Date,Time");
196		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
197
198		Statement stmt = conn.createStatement();
199
200		ResultSet results = stmt.executeQuery("select MAX(ID) from sample8");
201		assertTrue(results.next());
202		assertEquals("Incorrect max", 6, results.getInt(1));
203		assertFalse(results.next());
204
205		results.close();
206		stmt.close();
207		conn.close();
	180
	181	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
	182	Statement stmt = conn.createStatement();
	183	ResultSet results = stmt.executeQuery("select MAX(ID) from sample8"))
	184	{
	185	assertTrue(results.next());
	186	assertEquals("Incorrect max", 6, results.getInt(1));
	187	assertFalse(results.next());
	188	}
208	189	}
209	190
210	191	@Test

212	193	{
213	194	Properties props = new Properties();
214	195	props.put("columnTypes", "Int,String,Date,Time");
215		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
216
217		Statement stmt = conn.createStatement();
218
219		ResultSet results = stmt.executeQuery("select max(name) from sample8 where id < 3");
220		assertTrue(results.next());
221		assertEquals("Incorrect max", "Mauricio Hernandez", results.getString(1));
222		assertFalse(results.next());
223
224		results.close();
225		stmt.close();
226		conn.close();
	196
	197	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
	198	Statement stmt = conn.createStatement();
	199	ResultSet results = stmt.executeQuery("select max(name) from sample8 where id < 3"))
	200	{
	201	assertTrue(results.next());
	202	assertEquals("Incorrect max", "Mauricio Hernandez", results.getString(1));
	203	assertFalse(results.next());
	204	}
227	205	}
228	206
229	207	@Test

231	209	{
232	210	Properties props = new Properties();
233	211	props.put("columnTypes", "Int,String,Date,Time");
234		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
235
236		Statement stmt = conn.createStatement();
237
238		ResultSet results = stmt.executeQuery("select MAX(Name) from sample8 where ID = 999");
239		assertTrue(results.next());
240		assertEquals("Incorrect max", null, results.getObject(1));
241		assertFalse(results.next());
242
243		results.close();
244		stmt.close();
245		conn.close();
	212
	213	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
	214	Statement stmt = conn.createStatement();
	215	ResultSet results = stmt.executeQuery("select MAX(Name) from sample8 where ID = 999"))
	216	{
	217	assertTrue(results.next());
	218	assertEquals("Incorrect max", null, results.getObject(1));
	219	assertFalse(results.next());
	220	}
246	221	}
247	222
248	223	@Test
249	224	public void testMaxNoResultsExpression() throws SQLException
250	225	{
251		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath);
252
253		Statement stmt = conn.createStatement();
254
255		ResultSet results = stmt.executeQuery("SELECT MAX(ID)+1 FROM sample8 WHERE ID > 999");
256		assertTrue(results.next());
257		assertEquals("Incorrect max", null, results.getObject(1));
258		assertFalse(results.next());
259
260		results.close();
261		stmt.close();
262		conn.close();
	226	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath);
	227	Statement stmt = conn.createStatement();
	228	ResultSet results = stmt.executeQuery("SELECT MAX(ID)+1 FROM sample8 WHERE ID > 999"))
	229	{
	230	assertTrue(results.next());
	231	assertEquals("Incorrect max", null, results.getObject(1));
	232	assertFalse(results.next());
	233	}
263	234	}
264	235
265	236	@Test

267	238	{
268	239	Properties props = new Properties();
269	240	props.put("columnTypes", "Double,Double,Double,Double,Double,Double,Double");
270		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
271
272		Statement stmt = conn.createStatement();
273
274		ResultSet results = stmt.executeQuery("SELECT ROUND(MAX(C5)) FROM numeric");
275		assertTrue(results.next());
276		assertEquals("Incorrect max", 3, results.getInt(1));
277		assertFalse(results.next());
278
279		results.close();
280		stmt.close();
281		conn.close();
	241
	242	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
	243	Statement stmt = conn.createStatement();
	244	ResultSet results = stmt.executeQuery("SELECT ROUND(MAX(C5)) FROM numeric"))
	245	{
	246	assertTrue(results.next());
	247	assertEquals("Incorrect max", 3, results.getInt(1));
	248	assertFalse(results.next());
	249	}
282	250	}
283	251
284	252	@Test

286	254	{
287	255	Properties props = new Properties();
288	256	props.put("columnTypes", "Int,String,Date,Time");
289		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
290
291		Statement stmt = conn.createStatement();
292
293		ResultSet results = stmt.executeQuery("select max(d) from sample8");
294		assertTrue(results.next());
295		assertEquals("Incorrect max", "2010-03-28", results.getObject(1).toString());
296		assertFalse(results.next());
297
298		results.close();
299		stmt.close();
300		conn.close();
	257
	258	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
	259	Statement stmt = conn.createStatement();
	260	ResultSet results = stmt.executeQuery("select max(d) from sample8"))
	261	{
	262	assertTrue(results.next());
	263	assertEquals("Incorrect max", "2010-03-28", results.getObject(1).toString());
	264	assertFalse(results.next());
	265	}
301	266	}
302	267
303	268	@Test

305	270	{
306	271	Properties props = new Properties();
307	272	props.put("columnTypes", "Int,String,Date,Time");
308		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
309
310		Statement stmt = conn.createStatement();
311
312		ResultSet results = stmt.executeQuery("select MIN(ID) from sample8");
313		assertTrue(results.next());
314		assertEquals("Incorrect min", 1, results.getInt(1));
315		assertFalse(results.next());
316
317		results.close();
318		stmt.close();
319		conn.close();
	273
	274	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
	275	Statement stmt = conn.createStatement();
	276	ResultSet results = stmt.executeQuery("select MIN(ID) from sample8"))
	277	{
	278	assertTrue(results.next());
	279	assertEquals("Incorrect min", 1, results.getInt(1));
	280	assertFalse(results.next());
	281	}
320	282	}
321	283
322	284	@Test

324	286	{
325	287	Properties props = new Properties();
326	288	props.put("columnTypes", "Int,String,String,Timestamp");
327		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
328
329		Statement stmt = conn.createStatement();
330
331		ResultSet results = stmt.executeQuery("select min(upper(name)) from sample8 where id < 3");
332		assertTrue(results.next());
333		assertEquals("Incorrect min", "JUAN PABLO MORALES", results.getString(1));
334		assertFalse(results.next());
335
336		results.close();
337		stmt.close();
338		conn.close();
	289
	290	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
	291	Statement stmt = conn.createStatement();
	292	ResultSet results = stmt.executeQuery("select min(upper(name)) from sample8 where id < 3"))
	293	{
	294	assertTrue(results.next());
	295	assertEquals("Incorrect min", "JUAN PABLO MORALES", results.getString(1));
	296	assertFalse(results.next());
	297	}
339	298	}
340	299
341	300	@Test

343	302	{
344	303	Properties props = new Properties();
345	304	props.put("columnTypes", "Int,String,Date,Time");
346		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
347
348		Statement stmt = conn.createStatement();
349
350		ResultSet results = stmt.executeQuery("select MIN(ID), MAX(ID) from sample8");
351		assertTrue(results.next());
352		assertEquals("Incorrect min", 1, results.getInt(1));
353		assertEquals("Incorrect max", 6, results.getInt(2));
354		assertFalse(results.next());
355
356		results.close();
357		stmt.close();
358		conn.close();
	305	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
	306	Statement stmt = conn.createStatement();
	307	ResultSet results = stmt.executeQuery("select MIN(ID), MAX(ID) from sample8"))
	308	{
	309	assertTrue(results.next());
	310	assertEquals("Incorrect min", 1, results.getInt(1));
	311	assertEquals("Incorrect max", 6, results.getInt(2));
	312	assertFalse(results.next());
	313	}
359	314	}
360	315
361	316	@Test

363	318	{
364	319	Properties props = new Properties();
365	320	props.put("columnTypes", "Int,String,Date,Time");
366		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
367
368		Statement stmt = conn.createStatement();
369
370		ResultSet results = stmt.executeQuery("select SUM(ID) from sample8");
371		assertTrue(results.next());
372		assertEquals("Incorrect sum", 21, results.getInt(1));
373		assertFalse(results.next());
374
375		results.close();
376		stmt.close();
377		conn.close();
	321	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
	322	Statement stmt = conn.createStatement();
	323	ResultSet results = stmt.executeQuery("select SUM(ID) from sample8"))
	324	{
	325	assertTrue(results.next());
	326	assertEquals("Incorrect sum", 21, results.getInt(1));
	327	assertFalse(results.next());
	328	}
378	329	}
379	330
380	331	@Test

382	333	{
383	334	Properties props = new Properties();
384	335	props.put("columnTypes", "Int,Int,Int,Long,Double,Double,Double");
385		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
386
387		Statement stmt = conn.createStatement();
388
389		ResultSet results = stmt.executeQuery("select sum(c4), sum(c5) from numeric");
390		assertTrue(results.next());
391		assertEquals("Incorrect sum", 989999995600L, results.getLong(1));
392		assertEquals("Incorrect sum", "3.14", results.getString(2));
393		assertFalse(results.next());
394
395		results.close();
396		stmt.close();
397		conn.close();
	336	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
	337	Statement stmt = conn.createStatement();
	338	ResultSet results = stmt.executeQuery("select sum(c4), sum(c5) from numeric"))
	339	{
	340	assertTrue(results.next());
	341	assertEquals("Incorrect sum", 989999995600L, results.getLong(1));
	342	assertEquals("Incorrect sum", "3.14", results.getString(2));
	343	assertFalse(results.next());
	344	}
398	345	}
399	346
400	347	@Test

402	349	{
403	350	Properties props = new Properties();
404	351	props.put("columnTypes", "Int,String,Date,Time");
405		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
406
407		Statement stmt = conn.createStatement();
408
409		ResultSet results = stmt.executeQuery("select SUM(ID) from sample8 where id > 999");
410		assertTrue(results.next());
411		assertEquals("Incorrect sum", null, results.getObject(1));
412		assertFalse(results.next());
413
414		results.close();
415		stmt.close();
416		conn.close();
	352	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
	353	Statement stmt = conn.createStatement();
	354	ResultSet results = stmt.executeQuery("select SUM(ID) from sample8 where id > 999"))
	355	{
	356	assertTrue(results.next());
	357	assertEquals("Incorrect sum", null, results.getObject(1));
	358	assertFalse(results.next());
	359	}
417	360	}
418	361
419	362	@Test

421	364	{
422	365	Properties props = new Properties();
423	366	props.put("columnTypes", "Int,String,Date,Time");
424		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
425
426		Statement stmt = conn.createStatement();
427
428		ResultSet results = stmt.executeQuery("select AVG(ID) from sample8");
429		assertTrue(results.next());
430		assertEquals("Incorrect avg", "3.5", results.getString(1));
431		assertFalse(results.next());
432
433		results.close();
434		stmt.close();
435		conn.close();
436		}
437
	367	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
	368	Statement stmt = conn.createStatement();
	369	ResultSet results = stmt.executeQuery("select AVG(ID) from sample8"))
	370	{
	371	assertTrue(results.next());
	372	assertEquals("Incorrect avg", "3.5", results.getString(1));
	373	assertFalse(results.next());
	374	}
	375	}
	376
438	377	@Test
439	378	public void testAvgTwoColumns() throws SQLException
440	379	{
441	380	Properties props = new Properties();
442	381	props.put("columnTypes", "Int,Int,Int,Long,Double,Double,Double");
443		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
444
445		Statement stmt = conn.createStatement();
446
447		ResultSet results = stmt.executeQuery("select avg(c2), avg(c5) from numeric");
448		assertTrue(results.next());
449		assertEquals("Incorrect avg", "-497.5", results.getString(1));
450		assertEquals("Incorrect avg", "1.57", results.getString(2));
451		assertFalse(results.next());
452
453		results.close();
454		stmt.close();
455		conn.close();
	382	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
	383	Statement stmt = conn.createStatement();
	384	ResultSet results = stmt.executeQuery("select avg(c2), avg(c5) from numeric"))
	385	{
	386	assertTrue(results.next());
	387	assertEquals("Incorrect avg", "-497.5", results.getString(1));
	388	assertEquals("Incorrect avg", "1.57", results.getString(2));
	389	assertFalse(results.next());
	390	}
456	391	}
457	392
458	393	@Test

460	395	{
461	396	Properties props = new Properties();
462	397	props.put("columnTypes", "Int,String,Date,Time");
463		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
464
465		Statement stmt = conn.createStatement();
466
467		ResultSet results = stmt.executeQuery("select AVG(ID) from sample8 where id > 999");
468		assertTrue(results.next());
469		assertEquals("Incorrect avg", null, results.getObject(1));
470		assertFalse(results.next());
471
472		results.close();
473		stmt.close();
474		conn.close();
475		}
476
	398	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
	399	Statement stmt = conn.createStatement();
	400	ResultSet results = stmt.executeQuery("select AVG(ID) from sample8 where id > 999"))
	401	{
	402	assertTrue(results.next());
	403	assertEquals("Incorrect avg", null, results.getObject(1));
	404	assertFalse(results.next());
	405	}
	406	}
	407
477	408	@Test
478	409	public void testCountDistinct() throws SQLException
479	410	{

483	414	props.put("fileExtension", ".txt");
484	415	props.put("commentChar", "#");
485	416	props.put("columnTypes", "Date,Integer,Integer,Integer,Integer,Double");
486		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
487
488		Statement stmt = conn.createStatement();
489
490		ResultSet results = stmt.executeQuery("select count(distinct FROM_ACCT), count(distinct FROM_BLZ) from transactions");
491		assertTrue(results.next());
492		assertEquals("Incorrect count FROM_ACCT", 4, results.getInt(1));
493		assertEquals("Incorrect count FROM_BLZ", 3, results.getInt(2));
494		assertFalse(results.next());
495
496		results.close();
497		stmt.close();
498		conn.close();
499		}
500
	417
	418	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
	419	Statement stmt = conn.createStatement();
	420	ResultSet results = stmt.executeQuery("select count(distinct FROM_ACCT), count(distinct FROM_BLZ) from transactions"))
	421	{
	422	assertTrue(results.next());
	423	assertEquals("Incorrect count FROM_ACCT", 4, results.getInt(1));
	424	assertEquals("Incorrect count FROM_BLZ", 3, results.getInt(2));
	425	assertFalse(results.next());
	426	}
	427	}
	428
501	429	@Test
502	430	public void testSumAvgDistinct() throws SQLException
503	431	{
504	432	Properties props = new Properties();
505	433	props.put("columnTypes", "Int,Int,Int,Date,Time");
506	434	props.put("dateFormat", "M/D/YYYY");
507		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
508
509		Statement stmt = conn.createStatement();
510
511		ResultSet results = stmt.executeQuery("select sum(distinct PurchaseCt), round(avg(distinct PurchaseCt)) from Purchase");
512		assertTrue(results.next());
513		assertEquals("Incorrect sum", 1 + 3 + 4 + 11, results.getInt(1));
514		assertEquals("Incorrect avg", Math.round((1 + 3 + 4 + 11) / 4.0), results.getInt(2));
515		assertFalse(results.next());
516
517		results.close();
518		stmt.close();
519		conn.close();
	435
	436	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
	437	Statement stmt = conn.createStatement();
	438	ResultSet results = stmt.executeQuery("select sum(distinct PurchaseCt), round(avg(distinct PurchaseCt)) from Purchase"))
	439	{
	440	assertTrue(results.next());
	441	assertEquals("Incorrect sum", 1 + 3 + 4 + 11, results.getInt(1));
	442	assertEquals("Incorrect avg", Math.round((1 + 3 + 4 + 11) / 4.0), results.getInt(2));
	443	assertFalse(results.next());
	444	}
520	445	}
521	446
522	447	@Test
523	448	public void testStringAgg() throws SQLException
524	449	{
525		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath);
526
527		Statement stmt = conn.createStatement();
528
529		ResultSet results = stmt.executeQuery("select STRING_AGG(ID, ';') from sample");
530		assertTrue(results.next());
531		assertEquals("Incorrect STRING_AGG", "Q123;A123;B234;C456;D789;X234", results.getString(1));
532		assertFalse(results.next());
533
534		results.close();
535		stmt.close();
536		conn.close();
	450	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath);
	451	Statement stmt = conn.createStatement();
	452	ResultSet results = stmt.executeQuery("select STRING_AGG(ID, ';') from sample"))
	453	{
	454	assertTrue(results.next());
	455	assertEquals("Incorrect STRING_AGG", "Q123;A123;B234;C456;D789;X234", results.getString(1));
	456	assertFalse(results.next());
	457	}
537	458	}
538	459	}

+144

-145

src/test/java/org/relique/jdbc/csv/TestCryptoFilter.java less more

45	45
46	46	/**
47	47	* This class is used to test the CsvJdbc driver.
48		*
	48	*
49	49	* @author Jonathan Ackerman
50	50	* @author JD Evora
51	51	* @author Chetan Gupta

85	85	String destination = filePath
86	86	+ System.getProperty("file.separator") + "scrambled_"
87	87	+ i + ".txt";
88		FileInputStream fis;
89		fis = new FileInputStream(source);
90		BufferedInputStream in = new BufferedInputStream(fis);
91		FileOutputStream fos = new FileOutputStream(destination);
92		BufferedOutputStream out = new BufferedOutputStream(fos);
93		byte[] buffer = new byte[sampleLength];
94		int len = 0;
95		while ((len = in.read(buffer)) >= 0)
96		{
97		out.write(buffer, 0, len);
98		}
99		in.close();
100		fis.close();
101		out.close();
102		fos.close();
	88
	89	try (FileInputStream fis = new FileInputStream(source);
	90	BufferedInputStream in = new BufferedInputStream(fis);
	91	FileOutputStream fos = new FileOutputStream(destination);
	92	BufferedOutputStream out = new BufferedOutputStream(fos))
	93	{
	94	byte[] buffer = new byte[sampleLength];
	95	int len = 0;
	96	while ((len = in.read(buffer)) >= 0)
	97	{
	98	out.write(buffer, 0, len);
	99	}
	100	}
103	101	}
104	102	}
105	103	catch (IOException e)

120	118	File file = new File(testFile);
121	119	assertTrue(file.delete());
122	120	}
123		}
	121	}
124	122
125	123	/**
126	124	* using a wrong codec will cause an exception.

133	131	props.put("cryptoFilterClassName", "org.relique.io.NotACodec");
134	132	props.put("cryptoFilterParameterTypes", "String");
135	133	props.put("cryptoFilterParameters", "@0y");
136		try
137		{
138		DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
	134
	135	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props))
	136	{
139	137	fail("managed to initialize not existing CryptoFilter");
140	138	}
141	139	catch (SQLException e)

153	151	props.put("cryptoFilterClassName", "org.relique.io.XORCipher");
154	152	props.put("cryptoFilterParameterTypes", "String");
155	153	props.put("cryptoFilterParameters", "gaius vipsanius agrippa");
156		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
157		+ filePath, props);
158
159		Statement stmt = conn.createStatement();
160
161		ResultSet results = stmt.executeQuery("SELECT * FROM scrambled");
162		assertTrue(results.next());
163		assertEquals("The key is wrong", "1", results.getString("key"));
164		assertEquals("The value is wrong", "uno", results.getString("value"));
165		assertTrue(results.next());
166		assertEquals("The key is wrong", "2", results.getString("key"));
167		assertEquals("The value is wrong", "due", results.getString("value"));
168		assertTrue(results.next());
169		assertEquals("The key is wrong", "3", results.getString("key"));
170		assertEquals("The value is wrong", "tre", results.getString("value"));
171		assertTrue(!results.next());
172		}
173
	154
	155	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	156	+ filePath, props);
	157	Statement stmt = conn.createStatement();
	158	ResultSet results = stmt.executeQuery("SELECT * FROM scrambled"))
	159	{
	160	assertTrue(results.next());
	161	assertEquals("The key is wrong", "1", results.getString("key"));
	162	assertEquals("The value is wrong", "uno", results.getString("value"));
	163	assertTrue(results.next());
	164	assertEquals("The key is wrong", "2", results.getString("key"));
	165	assertEquals("The value is wrong", "due", results.getString("value"));
	166	assertTrue(results.next());
	167	assertEquals("The key is wrong", "3", results.getString("key"));
	168	assertEquals("The value is wrong", "tre", results.getString("value"));
	169	assertTrue(!results.next());
	170	}
	171	}
	172
174	173	/**
175	174	* wrong key: behave as if the file was empty.
176	175	* @throws SQLException

183	182	props.put("cryptoFilterClassName", "org.relique.io.XORCipher");
184	183	props.put("cryptoFilterParameterTypes", "String");
185	184	props.put("cryptoFilterParameters", "marcus junius brutus");
186		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
187		+ filePath, props);
188
189		Statement stmt = conn.createStatement();
190
191		ResultSet results = stmt.executeQuery("SELECT * FROM scrambled");
192		assertFalse(results.next());
	185
	186	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	187	+ filePath, props);
	188	Statement stmt = conn.createStatement();
	189	ResultSet results = stmt.executeQuery("SELECT * FROM scrambled"))
	190	{
	191	assertFalse(results.next());
	192	}
193	193	}
194	194
195	195	/**

209	209	boolean generating_input_file = false;
210	210	if(generating_input_file)
211	211	{
212		EncryptedFileOutputStream out = null;
213	212	try
214	213	{
215	214	File f = new File(filePath, "scrambled_trailing.txt");
216	215	String filename = f.getAbsolutePath();
217	216	CryptoFilter cip = new XORCipher(new String("gaius vipsanius agrippa"));;
218		out = new EncryptedFileOutputStream(filename, cip );
219		out.write((new String("key,value\n")).getBytes());
220		out.write((new String("1,uno\n")).getBytes());
221		out.write((new String("\n")).getBytes());
222		out.write((new String("2,due\n")).getBytes());
223		out.write((new String("3,tre\n")).getBytes());
224		out.write((new String("\n")).getBytes());
	217	try (EncryptedFileOutputStream out = new EncryptedFileOutputStream(filename, cip ))
	218	{
	219	out.write((new String("key,value\n")).getBytes());
	220	out.write((new String("1,uno\n")).getBytes());
	221	out.write((new String("\n")).getBytes());
	222	out.write((new String("2,due\n")).getBytes());
	223	out.write((new String("3,tre\n")).getBytes());
	224	out.write((new String("\n")).getBytes());
	225	}
225	226	}
226	227	catch (FileNotFoundException e)
227	228	{

231	232	{
232	233	e.printStackTrace();
233	234	}
234		finally
235		{
236		try
237		{
238		if (out != null)
239		out.close();
240		}
241		catch (IOException e)
242		{
243		}
244		}
245		}
246
247		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
248		+ filePath, props);
249
250		Statement stmt = conn.createStatement();
251
252		ResultSet results = stmt.executeQuery("SELECT * FROM scrambled_trailing");
253		assertTrue(results.next());
254		assertEquals("The key is wrong", "1", results.getString("key"));
255		assertEquals("The value is wrong", "uno", results.getString("value"));
256		assertTrue(results.next());
257		assertEquals("The key is wrong", "2", results.getString("key"));
258		assertEquals("The value is wrong", "due", results.getString("value"));
259		assertTrue(results.next());
260		assertEquals("The key is wrong", "3", results.getString("key"));
261		assertEquals("The value is wrong", "tre", results.getString("value"));
262		assertTrue(!results.next());
	235	}
	236
	237	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	238	+ filePath, props);
	239	Statement stmt = conn.createStatement();
	240	ResultSet results = stmt.executeQuery("SELECT * FROM scrambled_trailing"))
	241	{
	242	assertTrue(results.next());
	243	assertEquals("The key is wrong", "1", results.getString("key"));
	244	assertEquals("The value is wrong", "uno", results.getString("value"));
	245	assertTrue(results.next());
	246	assertEquals("The key is wrong", "2", results.getString("key"));
	247	assertEquals("The value is wrong", "due", results.getString("value"));
	248	assertTrue(results.next());
	249	assertEquals("The key is wrong", "3", results.getString("key"));
	250	assertEquals("The value is wrong", "tre", results.getString("value"));
	251	assertTrue(!results.next());
	252	}
263	253	}
264	254
265	255	@Test

270	260	props.put("cryptoFilterClassName", "org.relique.io.XORCipher");
271	261	props.put("cryptoFilterParameterTypes", "String");
272	262	props.put("cryptoFilterParameters", "gaius vipsanius agrippa");
273		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
274		+ filePath, props);
275
276		Statement stmt = conn.createStatement();
277
278		ResultSet results = stmt.executeQuery("SELECT * FROM scrambled");
279		assertTrue(results.next());
280		assertEquals("The key is wrong", "1", results.getString("key"));
281		assertEquals("The value is wrong", "uno", results.getString("value"));
282		assertTrue(results.next());
283		assertEquals("The key is wrong", "2", results.getString("key"));
284		assertEquals("The value is wrong", "due", results.getString("value"));
285
286		results = stmt.executeQuery("SELECT * FROM scrambled");
287		assertTrue(results.next());
288		assertEquals("The key is wrong", "1", results.getString("key"));
289		assertEquals("The value is wrong", "uno", results.getString("value"));
290		assertTrue(results.next());
291		assertEquals("The key is wrong", "2", results.getString("key"));
292		assertEquals("The value is wrong", "due", results.getString("value"));
293		assertTrue(results.next());
294		assertEquals("The key is wrong", "3", results.getString("key"));
295		assertEquals("The value is wrong", "tre", results.getString("value"));
296		assertTrue(!results.next());
	263
	264	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	265	+ filePath, props);
	266	Statement stmt = conn.createStatement())
	267	{
	268	try (ResultSet results = stmt.executeQuery("SELECT * FROM scrambled"))
	269	{
	270	assertTrue(results.next());
	271	assertEquals("The key is wrong", "1", results.getString("key"));
	272	assertEquals("The value is wrong", "uno", results.getString("value"));
	273	assertTrue(results.next());
	274	assertEquals("The key is wrong", "2", results.getString("key"));
	275	assertEquals("The value is wrong", "due", results.getString("value"));
	276	}
	277
	278	try (ResultSet results = stmt.executeQuery("SELECT * FROM scrambled"))
	279	{
	280	assertTrue(results.next());
	281	assertEquals("The key is wrong", "1", results.getString("key"));
	282	assertEquals("The value is wrong", "uno", results.getString("value"));
	283	assertTrue(results.next());
	284	assertEquals("The key is wrong", "2", results.getString("key"));
	285	assertEquals("The value is wrong", "due", results.getString("value"));
	286	assertTrue(results.next());
	287	assertEquals("The key is wrong", "3", results.getString("key"));
	288	assertEquals("The value is wrong", "tre", results.getString("value"));
	289	assertTrue(!results.next());
	290	}
	291	}
297	292	}
298	293
299	294	@Test

303	298	// dependent, this test will cause random regressions just because the
304	299	// load on the server performing the test might happen to be heavier
305	300	// during one function and lighter during the other!
306
	301
307	302	// creating variables - to be initialized later.
308		Properties props = null;
309		Connection conn = null;
310		Statement stmt = null;
311		ResultSet rset = null;
312
313	303	long timeNoEncrypt = 0;
314	304	long timeEncrypt = 0;
	305	long noEncryptStartMillis = 0;
	306	long encryptStartMillis = 0;
315	307
316	308	int encryptCount = 0;
317	309	int noEncryptCount = 0;

320	312	for (int i = 0; i < 2; i++)
321	313	{
322	314	// encrypted
323		props = new Properties();
	315	Properties props = new Properties();
324	316	props.put("fileExtension", ".txt");
325	317	props.put("cryptoFilterClassName", "org.relique.io.XORCipher");
326	318	props.put("cryptoFilterParameterTypes", "String");
327	319	props.put("cryptoFilterParameters", "gaius vipsanius agrippa");
328		Connection connEncr = DriverManager.getConnection("jdbc:relique:csv:"
	320
	321	try (Connection connEncr = DriverManager.getConnection("jdbc:relique:csv:"
329	322	+ filePath, props);
330		stmt = connEncr.createStatement();
331		long encryptStartMillis = System.currentTimeMillis();
332		rset = stmt.executeQuery("SELECT * FROM speedtest_decypher");
333		while (rset.next())
334		encryptCount++;
335		connEncr.close();
	323	Statement stmt = connEncr.createStatement())
	324	{
	325	encryptStartMillis = System.currentTimeMillis();
	326	try (ResultSet rset = stmt.executeQuery("SELECT * FROM speedtest_decypher"))
	327	{
	328	while (rset.next())
	329	encryptCount++;
	330	}
	331	}
336	332	long encryptEndMillis = System.currentTimeMillis();
337	333
338	334	timeEncrypt += encryptEndMillis - encryptStartMillis;

340	336	// non encrypted
341	337	props = new Properties();
342	338	props.put("fileExtension", ".csv");
343		conn = DriverManager.getConnection("jdbc:relique:csv:"
	339
	340	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
344	341	+ filePath, props);
345		stmt = conn.createStatement();
346		long noEncryptStartMillis = System.currentTimeMillis();
347		rset = stmt.executeQuery("SELECT * FROM speedtest_decypher");
348		while (rset.next())
349		noEncryptCount++;
350		conn.close();
	342	Statement stmt = conn.createStatement())
	343	{
	344	noEncryptStartMillis = System.currentTimeMillis();
	345	try (ResultSet rset = stmt.executeQuery("SELECT * FROM speedtest_decypher"))
	346	{
	347	while (rset.next())
	348	noEncryptCount++;
	349	}
	350	}
351	351	long noEncryptEndMillis = System.currentTimeMillis();
352
	352
353	353	timeNoEncrypt += noEncryptEndMillis - noEncryptStartMillis;
354	354	}
355	355

371	371	props.put("cryptoFilterParameterTypes", "String");
372	372	props.put("cryptoFilterParameters", "gaius vipsanius agrippa");
373	373
374		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
375		+ filePath, props);
376		Statement stmt = conn.createStatement();
377
378		for (int i = 0; i < testSize; i++)
379		{
380		ResultSet results = stmt.executeQuery("SELECT * FROM scrambled_" + i);
381		assertTrue(results.next());
382		while (results.next())
383		{
384		// nothing really
385		}
386		results.close();
387		}
388
389		stmt.close();
390		conn.close();
	374	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	375	+ filePath, props);
	376	Statement stmt = conn.createStatement())
	377	{
	378	for (int i = 0; i < testSize; i++)
	379	{
	380	try (ResultSet results = stmt.executeQuery("SELECT * FROM scrambled_" + i))
	381	{
	382	assertTrue(results.next());
	383	while (results.next())
	384	{
	385	// nothing really
	386	}
	387	}
	388	}
	389	}
391	390	}
392	391	}

+3631

-3358

src/test/java/org/relique/jdbc/csv/TestCsvDriver.java less more

47	47	import java.text.DateFormat;
48	48	import java.text.ParseException;
49	49	import java.text.SimpleDateFormat;
	50	import java.time.LocalDateTime;
	51	import java.time.ZoneId;
	52	import java.time.format.DateTimeFormatter;
50	53	import java.util.Locale;
51	54	import java.util.Properties;
52	55	import java.util.TimeZone;
53	56
54	57	import org.junit.BeforeClass;
55	58	import org.junit.Test;
56		import org.relique.jdbc.csv.CsvDriver;
57		import org.relique.jdbc.csv.CsvResultSet;
58	59
59	60	/**
60	61	* This class is used to test the CsvJdbc driver.
61		*
	62	*
62	63	* @author Jonathan Ackerman
63	64	* @author JD Evora
64	65	* @author Chetan Gupta

68	69	{
69	70	private static String filePath;
70	71	private static DateFormat toUTC;
	72	private static DateTimeFormatter toUTCDateTimeFormatter;
71	73
72	74	@BeforeClass
73	75	public static void setUp()

86	88	{
87	89	fail("Driver is not in the CLASSPATH -> " + e);
88	90	}
89		toUTC = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
90		toUTC.setTimeZone(TimeZone.getTimeZone("UTC"));
	91	toUTC = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
	92	toUTC.setTimeZone(TimeZone.getTimeZone("UTC"));
	93	toUTCDateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss").withZone(ZoneId.of("UTC"));
91	94	}
92	95
93	96	@Test
94	97	public void testWithDefaultValues() throws SQLException
95	98	{
96		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	99	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
97	100	+ filePath);
98	101
99		Statement stmt = conn.createStatement();
100
101		ResultSet results = stmt
102		.executeQuery("SELECT NAME,ID,EXTRA_FIELD FROM sample");
103
104		results.next();
105		assertEquals("Incorrect ID Value", "Q123", results.getString("ID"));
106		assertEquals("Incorrect NAME Value", "\"S,\"", results
107		.getString("NAME"));
108		assertEquals("Incorrect EXTRA_FIELD Value", "F", results
109		.getString("EXTRA_FIELD"));
110
111		assertEquals("Incorrect Column 1 Value", "\"S,\"", results.getString(1));
112		assertEquals("Incorrect Column 2 Value", "Q123", results.getString(2));
113		assertEquals("Incorrect Column 3 Value", "F", results.getString(3));
114
115		results.next();
116		assertEquals("Incorrect ID Value", "A123", results.getString("ID"));
117		assertEquals("Incorrect NAME Value", "Jonathan Ackerman", results
118		.getString("NAME"));
119		assertEquals("Incorrect EXTRA_FIELD Value", "A", results
120		.getString("EXTRA_FIELD"));
121
122		results.next();
123		assertEquals("Incorrect ID Value", "B234", results.getString("ID"));
124		assertEquals("Incorrect NAME Value", "Grady O'Neil", results
125		.getString("NAME"));
126		assertEquals("Incorrect EXTRA_FIELD Value", "B", results
127		.getString("EXTRA_FIELD"));
128
129		results.next();
130		assertEquals("Incorrect ID Value", "C456", results.getString("ID"));
131		assertEquals("Incorrect NAME Value", "Susan, Peter and Dave", results
132		.getString("NAME"));
133		assertEquals("Incorrect EXTRA_FIELD Value", "C", results
134		.getString("EXTRA_FIELD"));
135
136		results.next();
137		assertEquals("Incorrect ID Value", "D789", results.getString("ID"));
138		assertEquals("Incorrect NAME Value", "Amelia \"meals\" Maurice",
139		results.getString("NAME"));
140		assertEquals("Incorrect EXTRA_FIELD Value", "E", results
141		.getString("EXTRA_FIELD"));
142
143		results.next();
144		assertEquals("Incorrect ID Value", "X234", results.getString("ID"));
145		assertEquals("Incorrect NAME Value",
146		"Peter \"peg leg\", Jimmy & Samantha \"Sam\"", results
147		.getString("NAME"));
148		assertEquals("Incorrect EXTRA_FIELD Value", "G", results
149		.getString("EXTRA_FIELD"));
150
151		results.close();
152		stmt.close();
153		conn.close();
	102	Statement stmt = conn.createStatement();
	103
	104	ResultSet results = stmt
	105	.executeQuery("SELECT NAME,ID,EXTRA_FIELD FROM sample"))
	106	{
	107	results.next();
	108	assertEquals("Incorrect ID Value", "Q123", results.getString("ID"));
	109	assertEquals("Incorrect NAME Value", "\"S,\"", results
	110	.getString("NAME"));
	111	assertEquals("Incorrect EXTRA_FIELD Value", "F", results
	112	.getString("EXTRA_FIELD"));
	113
	114	assertEquals("Incorrect Column 1 Value", "\"S,\"", results.getString(1));
	115	assertEquals("Incorrect Column 2 Value", "Q123", results.getString(2));
	116	assertEquals("Incorrect Column 3 Value", "F", results.getString(3));
	117
	118	results.next();
	119	assertEquals("Incorrect ID Value", "A123", results.getString("ID"));
	120	assertEquals("Incorrect NAME Value", "Jonathan Ackerman", results
	121	.getString("NAME"));
	122	assertEquals("Incorrect EXTRA_FIELD Value", "A", results
	123	.getString("EXTRA_FIELD"));
	124
	125	results.next();
	126	assertEquals("Incorrect ID Value", "B234", results.getString("ID"));
	127	assertEquals("Incorrect NAME Value", "Grady O'Neil", results
	128	.getString("NAME"));
	129	assertEquals("Incorrect EXTRA_FIELD Value", "B", results
	130	.getString("EXTRA_FIELD"));
	131
	132	results.next();
	133	assertEquals("Incorrect ID Value", "C456", results.getString("ID"));
	134	assertEquals("Incorrect NAME Value", "Susan, Peter and Dave", results
	135	.getString("NAME"));
	136	assertEquals("Incorrect EXTRA_FIELD Value", "C", results
	137	.getString("EXTRA_FIELD"));
	138
	139	results.next();
	140	assertEquals("Incorrect ID Value", "D789", results.getString("ID"));
	141	assertEquals("Incorrect NAME Value", "Amelia \"meals\" Maurice",
	142	results.getString("NAME"));
	143	assertEquals("Incorrect EXTRA_FIELD Value", "E", results
	144	.getString("EXTRA_FIELD"));
	145
	146	results.next();
	147	assertEquals("Incorrect ID Value", "X234", results.getString("ID"));
	148	assertEquals("Incorrect NAME Value",
	149	"Peter \"peg leg\", Jimmy & Samantha \"Sam\"", results
	150	.getString("NAME"));
	151	assertEquals("Incorrect EXTRA_FIELD Value", "G", results
	152	.getString("EXTRA_FIELD"));
	153	}
154	154	}
155	155
156	156	/**
157	157	* This creates several sentences with where and tests they work
158		*
	158	*
159	159	* @throws SQLException
160	160	*/
161	161	@Test
162	162	public void testWhereSimple() throws SQLException
163	163	{
164		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	164	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
165	165	+ filePath);
166	166
167		Statement stmt = conn.createStatement();
168
169		ResultSet results = stmt
170		.executeQuery("SELECT ID,Name FROM sample4 WHERE ID='03'");
171		assertTrue(results.next());
172		assertEquals("The name is wrong", "Maria Cristina Lucero", results
173		.getString("Name"));
174		try
175		{
176		results.getString("Job");
177		fail("Should not find the column 'Job'");
178		}
179		catch (SQLException e)
180		{
181		assertEquals("java.sql.SQLException: " + CsvResources.getString("invalidColumnName") + ": Job", "" + e);
182		}
183		assertTrue(!results.next());
	167	Statement stmt = conn.createStatement();
	168
	169	ResultSet results = stmt
	170	.executeQuery("SELECT ID,Name FROM sample4 WHERE ID='03'"))
	171	{
	172	assertTrue(results.next());
	173	assertEquals("The name is wrong", "Maria Cristina Lucero", results
	174	.getString("Name"));
	175	try
	176	{
	177	results.getString("Job");
	178	fail("Should not find the column 'Job'");
	179	}
	180	catch (SQLException e)
	181	{
	182	assertEquals("java.sql.SQLException: " + CsvResources.getString("invalidColumnName") + ": Job", "" + e);
	183	}
	184	assertTrue(!results.next());
	185	}
184	186	}
185	187
186	188	/**
187	189	* fields in different order than in source file.
188		*
	190	*
189	191	* @throws SQLException
190	192	*/
191	193	@Test
192	194	public void testWhereShuffled() throws SQLException
193	195	{
194		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	196	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
195	197	+ filePath);
196	198
197		Statement stmt = conn.createStatement();
198
199		ResultSet results = stmt
200		.executeQuery("SELECT Job,ID,Name FROM sample4 WHERE ID='02'");
201		assertTrue("no results found - should be one", results.next());
202		assertEquals("The name is wrong", "Mauricio Hernandez", results
203		.getString("Name"));
204		assertEquals("The job is wrong", "Project Manager", results
205		.getString("Job"));
206		assertTrue("more than one matching records", !results.next());
	199	Statement stmt = conn.createStatement();
	200
	201	ResultSet results = stmt
	202	.executeQuery("SELECT Job,ID,Name FROM sample4 WHERE ID='02'"))
	203	{
	204	assertTrue("no results found - should be one", results.next());
	205	assertEquals("The name is wrong", "Mauricio Hernandez", results
	206	.getString("Name"));
	207	assertEquals("The job is wrong", "Project Manager", results
	208	.getString("Job"));
	209	assertTrue("more than one matching records", !results.next());
	210	}
207	211	}
208	212
209	213	@Test

213	217	props.put("fileExtension", "");
214	218	props.put("separator", ";");
215	219
216		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
217		+ filePath, props);
218
219		Statement stmt = conn.createStatement();
220
221		ResultSet results = stmt
222		.executeQuery("SELECT NAME,ID,EXTRA_FIELD FROM sample");
223
224		results.next();
225		assertTrue("Incorrect ID Value", results.getString("ID").equals("Q123"));
226		assertTrue("Incorrect NAME Value", results.getString("NAME").equals(
227		"\"S;\""));
228		assertTrue("Incorrect EXTRA_FIELD Value", results.getString(
229		"EXTRA_FIELD").equals("F"));
230
231		results.next();
232		assertTrue("Incorrect ID Value", results.getString("ID").equals("A123"));
233		assertTrue("Incorrect NAME Value", results.getString("NAME").equals(
234		"Jonathan Ackerman"));
235		assertTrue("Incorrect EXTRA_FIELD Value", results.getString(
236		"EXTRA_FIELD").equals("A"));
237
238		results.next();
239		assertTrue("Incorrect ID Value", results.getString("ID").equals("B234"));
240		assertTrue("Incorrect NAME Value", results.getString("NAME").equals(
241		"Grady O'Neil"));
242		assertTrue("Incorrect EXTRA_FIELD Value", results.getString(
243		"EXTRA_FIELD").equals("B"));
244
245		results.next();
246		assertTrue("Incorrect ID Value", results.getString("ID").equals("C456"));
247		assertTrue("Incorrect NAME Value", results.getString("NAME").equals(
248		"Susan; Peter and Dave"));
249		assertTrue("Incorrect EXTRA_FIELD Value", results.getString(
250		"EXTRA_FIELD").equals("C"));
251
252		results.next();
253		assertTrue("Incorrect ID Value", results.getString("ID").equals("D789"));
254		assertTrue("Incorrect NAME Value", results.getString("NAME").equals(
255		"Amelia \"meals\" Maurice"));
256		assertTrue("Incorrect EXTRA_FIELD Value", results.getString(
257		"EXTRA_FIELD").equals("E"));
258
259		results.next();
260		assertTrue("Incorrect ID Value", results.getString("ID").equals("X234"));
261		assertTrue("Incorrect NAME Value", results.getString("NAME").equals(
262		"Peter \"peg leg\"; Jimmy & Samantha \"Sam\""));
263		assertTrue("Incorrect EXTRA_FIELD Value", results.getString(
264		"EXTRA_FIELD").equals("G"));
265
266		results.close();
267		stmt.close();
268		conn.close();
	220	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	221	+ filePath, props);
	222
	223	Statement stmt = conn.createStatement();
	224
	225	ResultSet results = stmt
	226	.executeQuery("SELECT NAME,ID,EXTRA_FIELD FROM sample"))
	227	{
	228	results.next();
	229	assertTrue("Incorrect ID Value", results.getString("ID").equals("Q123"));
	230	assertTrue("Incorrect NAME Value", results.getString("NAME").equals(
	231	"\"S;\""));
	232	assertTrue("Incorrect EXTRA_FIELD Value", results.getString(
	233	"EXTRA_FIELD").equals("F"));
	234
	235	results.next();
	236	assertTrue("Incorrect ID Value", results.getString("ID").equals("A123"));
	237	assertTrue("Incorrect NAME Value", results.getString("NAME").equals(
	238	"Jonathan Ackerman"));
	239	assertTrue("Incorrect EXTRA_FIELD Value", results.getString(
	240	"EXTRA_FIELD").equals("A"));
	241
	242	results.next();
	243	assertTrue("Incorrect ID Value", results.getString("ID").equals("B234"));
	244	assertTrue("Incorrect NAME Value", results.getString("NAME").equals(
	245	"Grady O'Neil"));
	246	assertTrue("Incorrect EXTRA_FIELD Value", results.getString(
	247	"EXTRA_FIELD").equals("B"));
	248
	249	results.next();
	250	assertTrue("Incorrect ID Value", results.getString("ID").equals("C456"));
	251	assertTrue("Incorrect NAME Value", results.getString("NAME").equals(
	252	"Susan; Peter and Dave"));
	253	assertTrue("Incorrect EXTRA_FIELD Value", results.getString(
	254	"EXTRA_FIELD").equals("C"));
	255
	256	results.next();
	257	assertTrue("Incorrect ID Value", results.getString("ID").equals("D789"));
	258	assertTrue("Incorrect NAME Value", results.getString("NAME").equals(
	259	"Amelia \"meals\" Maurice"));
	260	assertTrue("Incorrect EXTRA_FIELD Value", results.getString(
	261	"EXTRA_FIELD").equals("E"));
	262
	263	results.next();
	264	assertTrue("Incorrect ID Value", results.getString("ID").equals("X234"));
	265	assertTrue("Incorrect NAME Value", results.getString("NAME").equals(
	266	"Peter \"peg leg\"; Jimmy & Samantha \"Sam\""));
	267	assertTrue("Incorrect EXTRA_FIELD Value", results.getString(
	268	"EXTRA_FIELD").equals("G"));
	269	}
269	270	}
270	271
271	272	@Test
272	273	public void testFindColumn() throws SQLException
273	274	{
274		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	275	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
275	276	+ filePath);
276	277
277		Statement stmt = conn.createStatement();
278
279		ResultSet results = stmt.executeQuery("SELECT * FROM sample");
280
281		assertEquals("Incorrect Column", 1, results.findColumn("ID"));
282		assertEquals("Incorrect Column", 2, results.findColumn("Name"));
283		assertEquals("Incorrect Column", 3, results.findColumn("EXTRA_FIELD"));
284
285		try
286		{
287		results.findColumn("foo");
288		fail("Should raise a java.sqlSQLException");
289		}
290		catch (SQLException e)
291		{
292		assertEquals("java.sql.SQLException: " + CsvResources.getString("invalidColumnName") + ": foo", "" + e);
293		}
294
295		results.close();
296		stmt.close();
297		conn.close();
	278	Statement stmt = conn.createStatement();
	279
	280	ResultSet results = stmt.executeQuery("SELECT * FROM sample"))
	281	{
	282	assertEquals("Incorrect Column", 1, results.findColumn("ID"));
	283	assertEquals("Incorrect Column", 2, results.findColumn("Name"));
	284	assertEquals("Incorrect Column", 3, results.findColumn("EXTRA_FIELD"));
	285
	286	try
	287	{
	288	results.findColumn("foo");
	289	fail("Should raise a java.sqlSQLException");
	290	}
	291	catch (SQLException e)
	292	{
	293	assertEquals("java.sql.SQLException: " + CsvResources.getString("invalidColumnName") + ": foo", "" + e);
	294	}
	295	}
298	296	}
299	297
300	298	@Test
301	299	public void testMetadata() throws SQLException
302	300	{
303		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	301	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
304	302	+ filePath);
305	303
306		Statement stmt = conn.createStatement();
307
308		ResultSet results = stmt.executeQuery("SELECT * FROM sample3");
309
310		ResultSetMetaData metadata = results.getMetaData();
311
312		assertEquals("Incorrect Table Name", "sample3", metadata
313		.getTableName(0));
314
315		assertEquals("Incorrect Column Name 1", "column 1", metadata
316		.getColumnName(1));
317		assertEquals("Incorrect Column Name 2", "column \"2\" two", metadata
318		.getColumnName(2));
319		assertEquals("Incorrect Column Name 3", "Column 3", metadata
320		.getColumnName(3));
321		assertEquals("Incorrect Column Name 4", "CoLuMn4", metadata
322		.getColumnName(4));
323		assertEquals("Incorrect Column Name 5", "COLumn5", metadata
324		.getColumnName(5));
325
326		results.close();
327		stmt.close();
328		conn.close();
	304	Statement stmt = conn.createStatement();
	305
	306	ResultSet results = stmt.executeQuery("SELECT * FROM sample3"))
	307	{
	308	ResultSetMetaData metadata = results.getMetaData();
	309
	310	assertEquals("Incorrect Table Name", "sample3", metadata
	311	.getTableName(0));
	312
	313	assertEquals("Incorrect Column Name 1", "column 1", metadata
	314	.getColumnName(1));
	315	assertEquals("Incorrect Column Name 2", "column \"2\" two", metadata
	316	.getColumnName(2));
	317	assertEquals("Incorrect Column Name 3", "Column 3", metadata
	318	.getColumnName(3));
	319	assertEquals("Incorrect Column Name 4", "CoLuMn4", metadata
	320	.getColumnName(4));
	321	assertEquals("Incorrect Column Name 5", "COLumn5", metadata
	322	.getColumnName(5));
	323	}
329	324	}
330	325
331	326	@Test

334	329	Properties props = new Properties();
335	330	props.put("suppressHeaders", "true");
336	331
337		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
338		+ filePath, props);
339
340		Statement stmt = conn.createStatement();
341
342		ResultSet results = stmt.executeQuery("SELECT * FROM sample");
343
344		ResultSetMetaData metadata = results.getMetaData();
345
346		assertTrue("Incorrect Table Name", metadata.getTableName(0).equals(
347		"sample"));
348
349		assertTrue("Incorrect Column Name 1", metadata.getColumnName(1).equals(
350		"COLUMN1"));
351		assertTrue("Incorrect Column Name 2", metadata.getColumnName(2).equals(
352		"COLUMN2"));
353		assertTrue("Incorrect Column Name 3", metadata.getColumnName(3).equals(
354		"COLUMN3"));
355
356		results.close();
357		stmt.close();
358		conn.close();
	332	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	333	+ filePath, props);
	334
	335	Statement stmt = conn.createStatement();
	336
	337	ResultSet results = stmt.executeQuery("SELECT * FROM sample"))
	338	{
	339	ResultSetMetaData metadata = results.getMetaData();
	340
	341	assertTrue("Incorrect Table Name", metadata.getTableName(0).equals(
	342	"sample"));
	343
	344	assertTrue("Incorrect Column Name 1", metadata.getColumnName(1).equals(
	345	"COLUMN1"));
	346	assertTrue("Incorrect Column Name 2", metadata.getColumnName(2).equals(
	347	"COLUMN2"));
	348	assertTrue("Incorrect Column Name 3", metadata.getColumnName(3).equals(
	349	"COLUMN3"));
	350	}
359	351	}
360	352
361	353	@Test

363	355	{
364	356	Properties props = new Properties();
365	357	props.put("columnTypes", "Int,String,String,Timestamp");
366		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
367		+ filePath, props);
368
369		Statement stmt = conn.createStatement();
370
371		ResultSet results = stmt
372		.executeQuery("SELECT id, name, job, start FROM sample5");
373
374		ResultSetMetaData metadata = results.getMetaData();
375
376		assertEquals("type of column 1 is incorrect", Types.INTEGER, metadata
377		.getColumnType(1));
378		assertEquals("type of column 2 is incorrect", Types.VARCHAR, metadata
379		.getColumnType(2));
380		assertEquals("type of column 3 is incorrect", Types.VARCHAR, metadata
381		.getColumnType(3));
382		assertEquals("type of column 4 is incorrect", Types.TIMESTAMP, metadata
383		.getColumnType(4));
384
385		assertEquals("type of column 1 is incorrect", "Int", metadata
386		.getColumnTypeName(1));
387		assertEquals("type of column 2 is incorrect", "String", metadata
388		.getColumnTypeName(2));
389		assertEquals("type of column 3 is incorrect", "String", metadata
390		.getColumnTypeName(3));
391		assertEquals("type of column 4 is incorrect", "Timestamp", metadata
392		.getColumnTypeName(4));
393
394		results.close();
395		stmt.close();
396		conn.close();
	358
	359	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	360	+ filePath, props);
	361
	362	Statement stmt = conn.createStatement();
	363
	364	ResultSet results = stmt
	365	.executeQuery("SELECT id, name, job, start FROM sample5"))
	366	{
	367	ResultSetMetaData metadata = results.getMetaData();
	368
	369	assertEquals("type of column 1 is incorrect", Types.INTEGER, metadata
	370	.getColumnType(1));
	371	assertEquals("type of column 2 is incorrect", Types.VARCHAR, metadata
	372	.getColumnType(2));
	373	assertEquals("type of column 3 is incorrect", Types.VARCHAR, metadata
	374	.getColumnType(3));
	375	assertEquals("type of column 4 is incorrect", Types.TIMESTAMP, metadata
	376	.getColumnType(4));
	377
	378	assertEquals("type of column 1 is incorrect", "Int", metadata
	379	.getColumnTypeName(1));
	380	assertEquals("type of column 2 is incorrect", "String", metadata
	381	.getColumnTypeName(2));
	382	assertEquals("type of column 3 is incorrect", "String", metadata
	383	.getColumnTypeName(3));
	384	assertEquals("type of column 4 is incorrect", "Timestamp", metadata
	385	.getColumnTypeName(4));
	386	}
397	387	}
398	388
399	389	@Test

401	391	{
402	392	Properties props = new Properties();
403	393	props.put("columnTypes", "Int,String,String,Timestamp");
404		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
405		+ filePath, props);
406
407		Statement stmt = conn.createStatement();
408
409		ResultSet results = stmt
410		.executeQuery("SELECT id+1 AS ID1, name, job, start FROM sample5");
411
412		ResultSetMetaData metadata = results.getMetaData();
413
414		assertEquals("size of column 1 is incorrect", 20, metadata
415		.getColumnDisplaySize(1));
416		assertEquals("size of column 2 is incorrect", 20, metadata
417		.getColumnDisplaySize(2));
418		assertEquals("size of column 3 is incorrect", 20, metadata
419		.getColumnDisplaySize(3));
420		assertEquals("size of column 4 is incorrect", 20, metadata
421		.getColumnDisplaySize(4));
422
423		results.close();
424		stmt.close();
425		conn.close();
	394
	395	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	396	+ filePath, props);
	397
	398	Statement stmt = conn.createStatement();
	399
	400	ResultSet results = stmt
	401	.executeQuery("SELECT id+1 AS ID1, name, job, start FROM sample5"))
	402	{
	403	ResultSetMetaData metadata = results.getMetaData();
	404
	405	assertEquals("size of column 1 is incorrect", 20, metadata
	406	.getColumnDisplaySize(1));
	407	assertEquals("size of column 2 is incorrect", 20, metadata
	408	.getColumnDisplaySize(2));
	409	assertEquals("size of column 3 is incorrect", 20, metadata
	410	.getColumnDisplaySize(3));
	411	assertEquals("size of column 4 is incorrect", 20, metadata
	412	.getColumnDisplaySize(4));
	413	}
426	414	}
427	415
428	416	@Test

432	420	Properties props = new Properties();
433	421	// header in file: ID,Name,Job,Start,timeoffset
434	422	props.put("columnTypes", "Int,String,String,Timestamp");
435		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
436		+ filePath, props);
437
438		Statement stmt = conn.createStatement();
439
440		ResultSet results = stmt
441		.executeQuery("SELECT start, id, name, job FROM sample5");
442
443		ResultSetMetaData metadata = results.getMetaData();
444
445		// TODO - this fails
446		assertEquals("type of column 1 is incorrect", Types.TIMESTAMP, metadata
447		.getColumnType(1));
448		assertEquals("type of column 2 is incorrect", Types.INTEGER, metadata
449		.getColumnType(2));
450		assertEquals("type of column 3 is incorrect", Types.VARCHAR, metadata
451		.getColumnType(3));
452		assertEquals("type of column 4 is incorrect", Types.VARCHAR, metadata
453		.getColumnType(4));
454
455		results.close();
456		stmt.close();
457		conn.close();
	423
	424	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	425	+ filePath, props);
	426
	427	Statement stmt = conn.createStatement();
	428
	429	ResultSet results = stmt
	430	.executeQuery("SELECT start, id, name, job FROM sample5"))
	431	{
	432	ResultSetMetaData metadata = results.getMetaData();
	433
	434	// TODO - this fails
	435	assertEquals("type of column 1 is incorrect", Types.TIMESTAMP, metadata
	436	.getColumnType(1));
	437	assertEquals("type of column 2 is incorrect", Types.INTEGER, metadata
	438	.getColumnType(2));
	439	assertEquals("type of column 3 is incorrect", Types.VARCHAR, metadata
	440	.getColumnType(3));
	441	assertEquals("type of column 4 is incorrect", Types.VARCHAR, metadata
	442	.getColumnType(4));
	443	}
458	444	}
459	445
460	446	@Test

464	450	props.put("columnTypes", "Int,String,String,Date,Time");
465	451	props.put("timeFormat", "HHmm");
466	452	props.put("dateFormat", "yyyy-MM-dd");
467		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
468		+ filePath, props);
469
470		Statement stmt = conn.createStatement();
471
472		ResultSet results = stmt
	453
	454	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	455	+ filePath, props);
	456
	457	Statement stmt = conn.createStatement();
	458
	459	ResultSet results = stmt
473	460	.executeQuery("SELECT id, start+timeoffset AS ts, 999 as C3, id - 4 as C4, " +
474		"ID * 1.1 as C5, Name+JOB AS c6, '.com' as C7, 'Mr '+Name as C8 FROM sample5");
475		ResultSetMetaData metadata = results.getMetaData();
476
477		assertEquals("type of column 1 is incorrect", Types.INTEGER, metadata
478		.getColumnType(1));
479		assertEquals("type of column 2 is incorrect", Types.TIMESTAMP, metadata
480		.getColumnType(2));
481		assertEquals("type of column 3 is incorrect", Types.INTEGER, metadata
482		.getColumnType(3));
483		assertEquals("type of column 4 is incorrect", Types.INTEGER, metadata
484		.getColumnType(4));
485		assertEquals("type of column 5 is incorrect", Types.DOUBLE, metadata
486		.getColumnType(5));
487		assertEquals("type of column 6 is incorrect", Types.VARCHAR, metadata
488		.getColumnType(6));
489		assertEquals("type of column 7 is incorrect", Types.VARCHAR, metadata
490		.getColumnType(7));
491		assertEquals("type of column 8 is incorrect", Types.VARCHAR, metadata
492		.getColumnType(8));
	461	"ID * 1.1 as C5, Name+JOB AS c6, '.com' as C7, 'Mr '+Name as C8 FROM sample5"))
	462	{
	463	ResultSetMetaData metadata = results.getMetaData();
	464
	465	assertEquals("type of column 1 is incorrect", Types.INTEGER, metadata
	466	.getColumnType(1));
	467	assertEquals("type of column 2 is incorrect", Types.TIMESTAMP, metadata
	468	.getColumnType(2));
	469	assertEquals("type of column 3 is incorrect", Types.INTEGER, metadata
	470	.getColumnType(3));
	471	assertEquals("type of column 4 is incorrect", Types.INTEGER, metadata
	472	.getColumnType(4));
	473	assertEquals("type of column 5 is incorrect", Types.DOUBLE, metadata
	474	.getColumnType(5));
	475	assertEquals("type of column 6 is incorrect", Types.VARCHAR, metadata
	476	.getColumnType(6));
	477	assertEquals("type of column 7 is incorrect", Types.VARCHAR, metadata
	478	.getColumnType(7));
	479	assertEquals("type of column 8 is incorrect", Types.VARCHAR, metadata
	480	.getColumnType(8));
	481	}
493	482	}
494	483
495	484	@Test
496	485	public void testMetadataWithTableAlias() throws SQLException
497	486	{
498		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	487	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
499	488	+ filePath);
500	489
501		Statement stmt = conn.createStatement();
502
503		ResultSet results = stmt
504		.executeQuery("select sx.id, sx.name as name from sample as sx");
505
506		ResultSetMetaData metadata = results.getMetaData();
507
508		assertEquals("Incorrect Table Name", "sample", metadata.getTableName(0));
509
510		assertEquals("Incorrect Column Name 1", "ID", metadata.getColumnName(1));
511		assertEquals("Incorrect Column Name 2", "NAME", metadata.getColumnName(2));
	490	Statement stmt = conn.createStatement();
	491
	492	ResultSet results = stmt
	493	.executeQuery("select sx.id, sx.name as name from sample as sx"))
	494	{
	495	ResultSetMetaData metadata = results.getMetaData();
	496
	497	assertEquals("Incorrect Table Name", "sample", metadata.getTableName(0));
	498
	499	assertEquals("Incorrect Column Name 1", "ID", metadata.getColumnName(1));
	500	assertEquals("Incorrect Column Name 2", "NAME", metadata.getColumnName(2));
	501	}
512	502	}
513	503
514	504	@Test

516	506	{
517	507	Properties props = new Properties();
518	508	props.put("columnTypes", "Int,String,String,Timestamp");
519		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
520		+ filePath, props);
521
522		Statement stmt = conn.createStatement();
523
524		ResultSet results = stmt
525		.executeQuery("SELECT id * 10 as XID, name, 1000 as dept FROM sample5");
526
527		ResultSetMetaData metadata = results.getMetaData();
528
529		assertEquals("name of column 1 is incorrect", "XID", metadata.getColumnName(1));
530		assertEquals("label of column 1 is incorrect", "XID", metadata.getColumnLabel(1));
531		assertEquals("name of column 2 is incorrect", "Name", metadata.getColumnName(2));
532		assertEquals("label of column 2 is incorrect", "Name", metadata.getColumnLabel(2));
533		assertEquals("name of column 3 is incorrect", "DEPT", metadata.getColumnName(3));
534		assertEquals("label of column 3 is incorrect", "DEPT", metadata.getColumnLabel(3));
535
536		results.close();
537		stmt.close();
538		conn.close();
	509
	510	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	511	+ filePath, props);
	512
	513	Statement stmt = conn.createStatement();
	514
	515	ResultSet results = stmt
	516	.executeQuery("SELECT id * 10 as XID, name, 1000 as dept FROM sample5"))
	517	{
	518	ResultSetMetaData metadata = results.getMetaData();
	519
	520	assertEquals("name of column 1 is incorrect", "XID", metadata.getColumnName(1));
	521	assertEquals("label of column 1 is incorrect", "XID", metadata.getColumnLabel(1));
	522	assertEquals("name of column 2 is incorrect", "Name", metadata.getColumnName(2));
	523	assertEquals("label of column 2 is incorrect", "Name", metadata.getColumnLabel(2));
	524	assertEquals("name of column 3 is incorrect", "DEPT", metadata.getColumnName(3));
	525	assertEquals("label of column 3 is incorrect", "DEPT", metadata.getColumnLabel(3));
	526	}
539	527	}
540	528
541	529	@Test
542	530	public void testDatabaseMetadataTableTypes() throws SQLException
543	531	{
544		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	532	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	533	+ filePath))
	534	{
	535	DatabaseMetaData metadata = conn.getMetaData();
	536	ResultSet results = metadata.getTableTypes();
	537	assertTrue(results.next());
	538	assertEquals("Wrong table type", "TABLE", results.getString(1));
	539	assertFalse(results.next());
	540	}
	541	}
	542
	543	@Test
	544	public void testDatabaseMetadataSchemas() throws SQLException
	545	{
	546	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	547	+ filePath))
	548	{
	549	DatabaseMetaData metadata = conn.getMetaData();
	550	ResultSet results = metadata.getSchemas();
	551	assertFalse(results.next());
	552	}
	553	}
	554
	555	@Test
	556	public void testDatabaseMetadataColumns() throws SQLException
	557	{
	558	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
545	559	+ filePath);
546		DatabaseMetaData metadata = conn.getMetaData();
547		ResultSet results = metadata.getTableTypes();
548		assertTrue(results.next());
549		assertEquals("Wrong table type", "TABLE", results.getString(1));
550		assertFalse(results.next());
551		}
552
553		@Test
554		public void testDatabaseMetadataSchemas() throws SQLException
555		{
556		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
557		+ filePath);
558		DatabaseMetaData metadata = conn.getMetaData();
559		ResultSet results = metadata.getSchemas();
560		assertFalse(results.next());
561		}
562
563		@Test
564		public void testDatabaseMetadataColumns() throws SQLException
565		{
566		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
567		+ filePath);
568		DatabaseMetaData metadata = conn.getMetaData();
569		ResultSet results = metadata.getColumns(null, null, "C D", null);
570		assertTrue(results.next());
571		assertEquals("Wrong table name", "C D", results.getString("TABLE_NAME"));
572		assertEquals("Wrong column name", "A", results.getString("COLUMN_NAME"));
573		assertTrue(results.next());
574		assertEquals("Wrong table name", "C D", results.getString("TABLE_NAME"));
575		assertEquals("Wrong column name", "B", results.getString("COLUMN_NAME"));
576		results.close();
577		conn.close();
	560	ResultSet results = conn.getMetaData().getColumns(null, null, "C D", null))
	561	{
	562	assertTrue(results.next());
	563	assertEquals("Wrong table name", "C D", results.getString("TABLE_NAME"));
	564	assertEquals("Wrong column name", "A", results.getString("COLUMN_NAME"));
	565	assertTrue(results.next());
	566	assertEquals("Wrong table name", "C D", results.getString("TABLE_NAME"));
	567	assertEquals("Wrong column name", "B", results.getString("COLUMN_NAME"));
	568	}
578	569	}
579	570
580	571	@Test

585	576	props.put("fileTailPattern", "-([0-9]{3})-([0-9]{8})");
586	577	props.put("fileTailParts", "location,file_date");
587	578	props.put("indexedFiles", "True");
588		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
589		+ filePath, props);
590		DatabaseMetaData metadata = conn.getMetaData();
591		ResultSet results = metadata.getColumns(null, null, "test", null);
592		assertTrue(results.next());
593		assertEquals("Wrong table name", "test", results.getString("TABLE_NAME"));
594		assertEquals("Wrong column name", "Datum", results.getString("COLUMN_NAME"));
595		assertTrue(results.next());
596		assertEquals("Wrong table name", "test", results.getString("TABLE_NAME"));
597		assertEquals("Wrong column name", "Tijd", results.getString("COLUMN_NAME"));
598		results.close();
599		conn.close();
	579
	580	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	581	+ filePath, props);
	582	ResultSet results = conn.getMetaData().getColumns(null, null, "test", null))
	583	{
	584	assertTrue(results.next());
	585	assertEquals("Wrong table name", "test", results.getString("TABLE_NAME"));
	586	assertEquals("Wrong column name", "Datum", results.getString("COLUMN_NAME"));
	587	assertTrue(results.next());
	588	assertEquals("Wrong table name", "test", results.getString("TABLE_NAME"));
	589	assertEquals("Wrong column name", "Tijd", results.getString("COLUMN_NAME"));
	590	}
600	591	}
601	592
602	593	@Test
603	594	public void testDatabaseMetadataProcedures() throws SQLException
604	595	{
605		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	596	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
606	597	+ filePath);
607		DatabaseMetaData metadata = conn.getMetaData();
608		ResultSet results = metadata.getProcedures(null, null, "*");
609		assertFalse(results.next());
	598	ResultSet results = conn.getMetaData().getProcedures(null, null, "*"))
	599	{
	600	assertFalse(results.next());
	601	}
610	602	}
611	603
612	604	@Test
613	605	public void testDatabaseMetadataUDTs() throws SQLException
614	606	{
615		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	607	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
616	608	+ filePath);
617		DatabaseMetaData metadata = conn.getMetaData();
618		ResultSet results = metadata.getUDTs(null, null, "test", null);
619		assertFalse(results.next());
	609	ResultSet results = conn.getMetaData().getUDTs(null, null, "test", null))
	610	{
	611	assertFalse(results.next());
	612	}
620	613	}
621	614
622	615	@Test
623	616	public void testDatabaseMetadataPrimaryKeys() throws SQLException
624	617	{
625		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	618	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
626	619	+ filePath);
627		DatabaseMetaData metadata = conn.getMetaData();
628		ResultSet results = metadata.getPrimaryKeys(null, null, "sample");
629		assertFalse(results.next());
	620	ResultSet results = conn.getMetaData().getPrimaryKeys(null, null, "sample"))
	621	{
	622	assertFalse(results.next());
	623	}
630	624	}
631	625
632	626	@Test
633	627	public void testDatabaseMetadataCatalogs() throws SQLException
634	628	{
635		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	629	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
636	630	+ filePath);
637		DatabaseMetaData metadata = conn.getMetaData();
638		ResultSet results = metadata.getCatalogs();
639		assertFalse(results.next());
	631	ResultSet results = conn.getMetaData().getCatalogs())
	632	{
	633	assertFalse(results.next());
	634	}
640	635	}
641	636
642	637	@Test
643	638	public void testDatabaseMetadataTypeInfo() throws SQLException
644	639	{
645		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	640	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
646	641	+ filePath);
647		DatabaseMetaData metadata = conn.getMetaData();
648		ResultSet results = metadata.getTypeInfo();
649		assertTrue(results.next());
650		assertEquals("TYPE_NAME is wrong", "String", results.getString("TYPE_NAME"));
651		assertEquals("DATA_TYPE is wrong", Types.VARCHAR, results.getInt("DATA_TYPE"));
652		assertEquals("NULLABLE is wrong", DatabaseMetaData.typeNullable, results.getShort("NULLABLE"));
	642	ResultSet results = conn.getMetaData().getTypeInfo())
	643	{
	644	assertTrue(results.next());
	645	assertEquals("TYPE_NAME is wrong", "String", results.getString("TYPE_NAME"));
	646	assertEquals("DATA_TYPE is wrong", Types.VARCHAR, results.getInt("DATA_TYPE"));
	647	assertEquals("NULLABLE is wrong", DatabaseMetaData.typeNullable, results.getShort("NULLABLE"));
	648	}
653	649	}
654	650
655	651	@Test

659	655	Properties props = new Properties();
660	656	props.put("columnTypes", "Int,String,String,Date");
661	657
662		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
663		+ filePath, props);
664		Statement stmt = conn.createStatement();
665		ResultSet results = stmt.executeQuery("SELECT ID, Name, Job, Start "
666		+ "FROM sample5 WHERE Job = 'Project Manager'");
667
668		assertTrue(results.next());
669		assertEquals("Integer column ID is wrong", new Integer(1), results
670		.getObject("id"));
671		assertEquals("Integer column 1 is wrong", new Integer(1), results
672		.getObject(1));
673		java.sql.Date shouldBe = java.sql.Date.valueOf("2001-01-02");
674		assertEquals("Date column Start is wrong", shouldBe, results
675		.getObject("start"));
676		assertEquals("Date column 4 is wrong", shouldBe, results.getObject(4));
677		assertEquals("The Name is wrong", "Juan Pablo Morales", results
678		.getObject("name"));
	658	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	659	+ filePath, props);
	660	Statement stmt = conn.createStatement();
	661	ResultSet results = stmt.executeQuery("SELECT ID, Name, Job, Start "
	662	+ "FROM sample5 WHERE Job = 'Project Manager'"))
	663	{
	664	assertTrue(results.next());
	665	assertEquals("Integer column ID is wrong", Integer.valueOf(1), results
	666	.getObject("id"));
	667	assertEquals("Integer column 1 is wrong", Integer.valueOf(1), results
	668	.getObject(1));
	669	java.sql.Date shouldBe = java.sql.Date.valueOf("2001-01-02");
	670	assertEquals("Date column Start is wrong", shouldBe, results
	671	.getObject("start"));
	672	assertEquals("Date column 4 is wrong", shouldBe, results.getObject(4));
	673	assertEquals("The Name is wrong", "Juan Pablo Morales", results
	674	.getObject("name"));
	675	}
679	676	}
680	677
681	678	@Test

685	682	Properties props = new Properties();
686	683	props.put("columnTypes", "Int,String,String,Date");
687	684
688		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
689		+ filePath, props);
690		Statement stmt = conn.createStatement();
691		ResultSet results = stmt.executeQuery("SELECT ID, Start, Name, Job "
692		+ "FROM sample5 WHERE Job = 'Project Manager'");
693
694		assertTrue(results.next());
695		assertEquals("Integer column ID is wrong", new Integer(1), results
696		.getObject("id"));
697		assertEquals("Integer column 1 is wrong", new Integer(1), results
698		.getObject(1));
699		java.sql.Date shouldBe = java.sql.Date.valueOf("2001-01-02");
700		assertEquals("Date column Start is wrong", shouldBe, results
701		.getObject("start"));
702		assertEquals("Date column 4 is wrong", shouldBe, results.getObject(2));
703		assertEquals("The Name is wrong", "Juan Pablo Morales", results
704		.getObject("name"));
	685	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	686	+ filePath, props);
	687	Statement stmt = conn.createStatement();
	688	ResultSet results = stmt.executeQuery("SELECT ID, Start, Name, Job "
	689	+ "FROM sample5 WHERE Job = 'Project Manager'"))
	690	{
	691	assertTrue(results.next());
	692	assertEquals("Integer column ID is wrong", Integer.valueOf(1), results
	693	.getObject("id"));
	694	assertEquals("Integer column 1 is wrong", Integer.valueOf(1), results
	695	.getObject(1));
	696	java.sql.Date shouldBe = java.sql.Date.valueOf("2001-01-02");
	697	assertEquals("Date column Start is wrong", shouldBe, results
	698	.getObject("start"));
	699	assertEquals("Date column 4 is wrong", shouldBe, results.getObject(2));
	700	assertEquals("The Name is wrong", "Juan Pablo Morales", results
	701	.getObject("name"));
	702	}
705	703	}
706	704
707	705	@Test

711	709	Properties props = new Properties();
712	710	props.put("columnTypes", "Int,String,String,Timestamp");
713	711
714		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
715		+ filePath, props);
716		Statement stmt = conn.createStatement();
717		ResultSet results = stmt.executeQuery("SELECT ID, Name, Job, Start "
718		+ "FROM sample5 WHERE Job = 'Project Manager'");
719
720		assertTrue(results.next());
721		DateFormat dfp = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
722		assertEquals("Integer column ID is wrong", new Integer(1), results
723		.getObject("id"));
724		assertEquals("Integer column 1 is wrong", new Integer(1), results
725		.getObject(1));
726		assertEquals("Date column Start is wrong", dfp.parse(results
727		.getString("start")), results.getObject("start"));
728		assertEquals("Date column 4 is wrong", dfp.parse(results
729		.getString("start")), results.getObject(4));
730		assertEquals("The Name is wrong", "Juan Pablo Morales", results
731		.getObject("name"));
	712	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	713	+ filePath, props);
	714	Statement stmt = conn.createStatement();
	715	ResultSet results = stmt.executeQuery("SELECT ID, Name, Job, Start "
	716	+ "FROM sample5 WHERE Job = 'Project Manager'"))
	717	{
	718	assertTrue(results.next());
	719	DateFormat dfp = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
	720	assertEquals("Integer column ID is wrong", Integer.valueOf(1), results
	721	.getObject("id"));
	722	assertEquals("Integer column 1 is wrong", Integer.valueOf(1), results
	723	.getObject(1));
	724	assertEquals("Date column Start is wrong", dfp.parse(results
	725	.getString("start")), results.getObject("start"));
	726	assertEquals("Date column 4 is wrong", dfp.parse(results
	727	.getString("start")), results.getObject(4));
	728	assertEquals("The Name is wrong", "Juan Pablo Morales", results
	729	.getObject("name"));
	730	}
732	731	}
733	732
734	733	/**

742	741	Properties props = new Properties();
743	742	props.put("columnTypes", "");
744	743
745		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
746		+ filePath, props);
747		Statement stmt = conn.createStatement();
748		ResultSet results = stmt.executeQuery("SELECT ID, Name, Job, Start "
749		+ "FROM sample5");
750
751		assertTrue(results.next());
752		ResultSetMetaData metadata = results.getMetaData();
753		assertEquals("type of column 1 is incorrect", Types.INTEGER, metadata
754		.getColumnType(1));
755		assertEquals("type of column 2 is incorrect", Types.VARCHAR, metadata
756		.getColumnType(2));
757		assertEquals("type of column 3 is incorrect", Types.VARCHAR, metadata
758		.getColumnType(3));
759		assertEquals("type of column 4 is incorrect", Types.TIMESTAMP, metadata
760		.getColumnType(4));
	744	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	745	+ filePath, props);
	746	Statement stmt = conn.createStatement();
	747	ResultSet results = stmt.executeQuery("SELECT ID, Name, Job, Start "
	748	+ "FROM sample5"))
	749	{
	750	assertTrue(results.next());
	751	ResultSetMetaData metadata = results.getMetaData();
	752	assertEquals("type of column 1 is incorrect", Types.INTEGER, metadata
	753	.getColumnType(1));
	754	assertEquals("type of column 2 is incorrect", Types.VARCHAR, metadata
	755	.getColumnType(2));
	756	assertEquals("type of column 3 is incorrect", Types.VARCHAR, metadata
	757	.getColumnType(3));
	758	assertEquals("type of column 4 is incorrect", Types.TIMESTAMP, metadata
	759	.getColumnType(4));
	760	}
761	761	}
762	762
763	763	@Test

776	776	props.put("locale", Locale.US.toString());
777	777	}
778	778
779		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
780		+ filePath, props);
781		Statement stmt = conn.createStatement();
782		ResultSet results = stmt.executeQuery("SELECT ID, D, T "
783		+ "FROM sunil_date_time");
784
785		assertTrue(results.next());
786		ResultSetMetaData metadata = results.getMetaData();
787		assertEquals("type of column 1 is incorrect", Types.INTEGER, metadata
788		.getColumnType(1));
789		assertEquals("type of column 2 is incorrect", Types.DATE, metadata
790		.getColumnType(2));
791		assertEquals("type of column 3 is incorrect", Types.TIME, metadata
792		.getColumnType(3));
	779	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	780	+ filePath, props);
	781	Statement stmt = conn.createStatement();
	782	ResultSet results = stmt.executeQuery("SELECT ID, D, T "
	783	+ "FROM sunil_date_time"))
	784	{
	785	assertTrue(results.next());
	786	ResultSetMetaData metadata = results.getMetaData();
	787	assertEquals("type of column 1 is incorrect", Types.INTEGER, metadata
	788	.getColumnType(1));
	789	assertEquals("type of column 2 is incorrect", Types.DATE, metadata
	790	.getColumnType(2));
	791	assertEquals("type of column 3 is incorrect", Types.TIME, metadata
	792	.getColumnType(3));
	793	}
793	794	}
794	795
795	796	@Test

799	800	Properties props = new Properties();
800	801	props.put("columnTypes", "");
801	802
802		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
803		+ filePath, props);
804		Statement stmt = conn.createStatement();
805		ResultSet results = stmt.executeQuery("SELECT * FROM sample5");
806
807		try
808		{
809		results.getMetaData();
810		fail("Should raise a java.sqlSQLException");
811		}
812		catch (SQLException e)
813		{
814		assertEquals("java.sql.SQLException: " + CsvResources.getString("cannotInferColumns"), "" + e);
	803	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	804	+ filePath, props);
	805	Statement stmt = conn.createStatement();
	806	ResultSet results = stmt.executeQuery("SELECT * FROM sample5"))
	807	{
	808	try
	809	{
	810	results.getMetaData();
	811	fail("Should raise a java.sqlSQLException");
	812	}
	813	catch (SQLException e)
	814	{
	815	assertEquals("java.sql.SQLException: " + CsvResources.getString("cannotInferColumns"), "" + e);
	816	}
815	817	}
816	818	}
817	819

826	828	Properties props = new Properties();
827	829	props.put("columnTypes", "Byte,Short,Integer,Long,Float,Double,BigDecimal");
828	830
829		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
830		+ filePath, props);
831		Statement stmt = conn.createStatement();
832		ResultSet results = stmt.executeQuery("SELECT C1, C2, C3, C4, C5, C6, C7 "
833		+ "FROM numeric");
834
835		assertTrue(results.next());
836		ResultSetMetaData metadata = results.getMetaData();
837		assertEquals("type of column 1 is incorrect", Types.TINYINT, metadata
838		.getColumnType(1));
839		assertEquals("type of column 2 is incorrect", Types.SMALLINT, metadata
840		.getColumnType(2));
841		assertEquals("type of column 3 is incorrect", Types.INTEGER, metadata
842		.getColumnType(3));
843		assertEquals("type of column 4 is incorrect", Types.BIGINT, metadata
844		.getColumnType(4));
845		assertEquals("type of column 5 is incorrect", Types.FLOAT, metadata
846		.getColumnType(5));
847		assertEquals("type of column 6 is incorrect", Types.DOUBLE, metadata
848		.getColumnType(6));
849		assertEquals("type of column 7 is incorrect", Types.DECIMAL, metadata
850		.getColumnType(7));
	831	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	832	+ filePath, props);
	833	Statement stmt = conn.createStatement();
	834	ResultSet results = stmt.executeQuery("SELECT C1, C2, C3, C4, C5, C6, C7 "
	835	+ "FROM numeric"))
	836	{
	837	assertTrue(results.next());
	838	ResultSetMetaData metadata = results.getMetaData();
	839	assertEquals("type of column 1 is incorrect", Types.TINYINT, metadata
	840	.getColumnType(1));
	841	assertEquals("type of column 2 is incorrect", Types.SMALLINT, metadata
	842	.getColumnType(2));
	843	assertEquals("type of column 3 is incorrect", Types.INTEGER, metadata
	844	.getColumnType(3));
	845	assertEquals("type of column 4 is incorrect", Types.BIGINT, metadata
	846	.getColumnType(4));
	847	assertEquals("type of column 5 is incorrect", Types.FLOAT, metadata
	848	.getColumnType(5));
	849	assertEquals("type of column 6 is incorrect", Types.DOUBLE, metadata
	850	.getColumnType(6));
	851	assertEquals("type of column 7 is incorrect", Types.DECIMAL, metadata
	852	.getColumnType(7));
	853	}
851	854	}
852	855
853	856	@Test

856	859	{
857	860	Properties props = new Properties();
858	861
859		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
860		+ filePath, props);
861		Statement stmt = conn.createStatement();
862		ResultSet results = stmt.executeQuery("SELECT ID, Name, Job, Start "
863		+ "FROM sample5 WHERE Job = 'Project Manager'");
864
865		assertTrue(results.next());
866		assertEquals("the start time is wrong", "2001-01-02 12:30:00", results
867		.getObject("start"));
868		assertEquals("The ID is wrong", "01", results.getObject("id"));
869		assertEquals("The Name is wrong", "Juan Pablo Morales", results
870		.getObject("name"));
	862	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	863	+ filePath, props);
	864	Statement stmt = conn.createStatement();
	865	ResultSet results = stmt.executeQuery("SELECT ID, Name, Job, Start "
	866	+ "FROM sample5 WHERE Job = 'Project Manager'"))
	867	{
	868	assertTrue(results.next());
	869	assertEquals("the start time is wrong", "2001-01-02 12:30:00", results
	870	.getObject("start"));
	871	assertEquals("The ID is wrong", "01", results.getObject("id"));
	872	assertEquals("The Name is wrong", "Juan Pablo Morales", results
	873	.getObject("name"));
	874	}
871	875	}
872	876
873	877	@Test
874	878	public void testBadColumnTypesFails() throws SQLException
875		{
	879	{
876	880	try
877	881	{
878	882	Properties props = new Properties();
879	883	props.put("columnTypes", "Varchar,Varchar");
880		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	884	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
881	885	+ filePath, props);
882	886
883		Statement stmt = conn.createStatement();
884
885		stmt.executeQuery("SELECT Id, Name FROM sample");
886		fail("Should raise a java.sqlSQLException");
	887	Statement stmt = conn.createStatement())
	888	{
	889	stmt.executeQuery("SELECT Id, Name FROM sample");
	890	fail("Should raise a java.sqlSQLException");
	891	}
887	892	}
888	893	catch (SQLException e)
889	894	{

893	898
894	899	@Test
895	900	public void testBadColumnNameFails() throws SQLException
896		{
	901	{
897	902	try
898	903	{
899	904	Properties props = new Properties();
900		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	905	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
901	906	+ filePath, props);
902	907
903		Statement stmt = conn.createStatement();
904
905		stmt.executeQuery("SELECT Id, XXXX FROM sample");
906		fail("Should raise a java.sqlSQLException");
	908	Statement stmt = conn.createStatement())
	909	{
	910	stmt.executeQuery("SELECT Id, XXXX FROM sample");
	911	fail("Should raise a java.sqlSQLException");
	912	}
907	913	}
908	914	catch (SQLException e)
909	915	{

913	919
914	920	@Test
915	921	public void testEmptyColumnTypesFails() throws SQLException
916		{
	922	{
917	923	try
918	924	{
919	925	Properties props = new Properties();
920	926	props.put("columnTypes", ",");
921		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	927
	928	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
922	929	+ filePath, props);
923	930
924		Statement stmt = conn.createStatement();
925
926		stmt.executeQuery("SELECT * FROM sample");
927		fail("Should raise a java.sqlSQLException");
	931	Statement stmt = conn.createStatement())
	932	{
	933	stmt.executeQuery("SELECT * FROM sample");
	934	fail("Should raise a java.sqlSQLException");
	935	}
928	936	}
929	937	catch (SQLException e)
930	938	{

939	947	Properties props = new Properties();
940	948	props.put("columnTypes", "Int,String,String,Timestamp");
941	949
942		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
943		+ filePath, props);
944		Statement stmt = conn.createStatement();
945		ResultSet results = stmt.executeQuery("SELECT * "
946		+ "FROM sample5 WHERE Job = 'Project Manager'");
947
948		assertTrue(results.next());
949		String target = "2001-01-02 12:30:00";
950		assertEquals("the start time is wrong", target, toUTC.format(results
951		.getObject("start")));
952		assertEquals("The ID is wrong", new Integer(1), results.getObject("id"));
953		assertEquals("The Name is wrong", "Juan Pablo Morales", results
954		.getObject("name"));
	950	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	951	+ filePath, props);
	952	Statement stmt = conn.createStatement();
	953	ResultSet results = stmt.executeQuery("SELECT * "
	954	+ "FROM sample5 WHERE Job = 'Project Manager'"))
	955	{
	956	assertTrue(results.next());
	957	String target = "2001-01-02 12:30:00";
	958	assertEquals("the start time is wrong", target, toUTC.format(results
	959	.getObject("start")));
	960	assertEquals("The ID is wrong", Integer.valueOf(1), results.getObject("id"));
	961	assertEquals("The Name is wrong", "Juan Pablo Morales", results
	962	.getObject("name"));
	963	}
955	964	}
956	965
957	966	@Test

964	973	// Give empty list so column types are inferred from data.
965	974	props.put("columnTypes.numeric", "");
966	975
967		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
968		+ filePath, props);
969		Statement stmt = conn.createStatement();
970		ResultSet results = stmt.executeQuery("SELECT * from sample5");
971		assertTrue(results.next());
972		assertEquals("The sample5 ID is wrong", new Integer(41), results.getObject("id"));
973		assertEquals("The sample5 Job is wrong", "Piloto", results.getObject("job"));
974		results.close();
975		results = stmt.executeQuery("SELECT ID,EXTRA_FIELD from sample");
976		assertTrue(results.next());
977		assertEquals("The sample ID is wrong", "Q123", results.getObject(1));
978		assertEquals("The sample EXTRA_FIELD is wrong", "F", results.getObject(2));
979		results.close();
980
981		// column types are inferred from data.
982		results = stmt.executeQuery("SELECT C2, 'X' as X from numeric");
983		assertTrue(results.next());
984		assertEquals("The numeric C2 is wrong", new Integer(-1010), results.getObject(1));
985		assertEquals("The numeric X is wrong", "X", results.getObject(2));
	976	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	977	+ filePath, props);
	978	Statement stmt = conn.createStatement())
	979	{
	980	try (ResultSet results = stmt.executeQuery("SELECT * from sample5"))
	981	{
	982	assertTrue(results.next());
	983	assertEquals("The sample5 ID is wrong", Integer.valueOf(41), results.getObject("id"));
	984	assertEquals("The sample5 Job is wrong", "Piloto", results.getObject("job"));
	985	}
	986	try (ResultSet results = stmt.executeQuery("SELECT ID,EXTRA_FIELD from sample"))
	987	{
	988	assertTrue(results.next());
	989	assertEquals("The sample ID is wrong", "Q123", results.getObject(1));
	990	assertEquals("The sample EXTRA_FIELD is wrong", "F", results.getObject(2));
	991	}
	992
	993	// column types are inferred from data.
	994	try (ResultSet results = stmt.executeQuery("SELECT C2, 'X' as X from numeric"))
	995	{
	996	assertTrue(results.next());
	997	assertEquals("The numeric C2 is wrong", Integer.valueOf(-1010), results.getObject(1));
	998	assertEquals("The numeric X is wrong", "X", results.getObject(2));
	999	}
	1000	}
986	1001	}
987	1002
988	1003	@Test

991	1006	Properties props = new Properties();
992	1007	props.put("suppressHeaders", "true");
993	1008
994		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
995		+ filePath, props);
996
997		Statement stmt = conn.createStatement();
998
999		ResultSet results = stmt.executeQuery("SELECT * FROM sample");
1000
1001		// header is now treated as normal data line
1002		results.next();
1003		assertTrue("Incorrect COLUMN1 Value", results.getString("COLUMN1")
1004		.equals("ID"));
1005		assertTrue("Incorrect COLUMN2 Value", results.getString("COLUMN2")
1006		.equals("NAME"));
1007		assertTrue("Incorrect COLUMN3 Value", results.getString("COLUMN3")
1008		.equals("EXTRA_FIELD"));
1009
1010		results.next();
1011		assertTrue("Incorrect COLUMN1 Value", results.getString("COLUMN1")
1012		.equals("Q123"));
1013		assertTrue("Incorrect COLUMN2 Value", results.getString("COLUMN2")
1014		.equals("\"S,\""));
1015		assertTrue("Incorrect COLUMN3 Value", results.getString("COLUMN3")
1016		.equals("F"));
1017
1018		results.next();
1019		assertTrue("Incorrect COLUMN1 Value", results.getString("COLUMN1")
1020		.equals("A123"));
1021		assertTrue("Incorrect COLUMN2 Value", results.getString("COLUMN2")
1022		.equals("Jonathan Ackerman"));
1023		assertTrue("Incorrect COLUMN3 Value", results.getString("COLUMN3")
1024		.equals("A"));
1025
1026		results.next();
1027		assertTrue("Incorrect COLUMN1 Value", results.getString("COLUMN1")
1028		.equals("B234"));
1029		assertTrue("Incorrect COLUMN2 Value", results.getString("COLUMN2")
1030		.equals("Grady O'Neil"));
1031		assertTrue("Incorrect COLUMN3 Value", results.getString("COLUMN3")
1032		.equals("B"));
1033
1034		results.next();
1035		assertTrue("Incorrect COLUMN1 Value", results.getString("COLUMN1")
1036		.equals("C456"));
1037		assertTrue("Incorrect COLUMN2 Value", results.getString("COLUMN2")
1038		.equals("Susan, Peter and Dave"));
1039		assertTrue("Incorrect COLUMN3 Value", results.getString("COLUMN3")
1040		.equals("C"));
1041
1042		results.next();
1043		assertTrue("Incorrect COLUMN1 Value", results.getString("COLUMN1")
1044		.equals("D789"));
1045		assertTrue("Incorrect COLUMN2 Value", results.getString("COLUMN2")
1046		.equals("Amelia \"meals\" Maurice"));
1047		assertTrue("Incorrect COLUMN3 Value", results.getString("COLUMN3")
1048		.equals("E"));
1049
1050		results.next();
1051		assertTrue("Incorrect COLUMN1 Value", results.getString("COLUMN1")
1052		.equals("X234"));
1053		assertTrue("Incorrect COLUMN2 Value", results.getString("COLUMN2")
1054		.equals("Peter \"peg leg\", Jimmy & Samantha \"Sam\""));
1055		assertTrue("Incorrect COLUMN3 Value", results.getString("COLUMN3")
1056		.equals("G"));
1057
1058		results.close();
1059		stmt.close();
1060		conn.close();
	1009	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	1010	+ filePath, props);
	1011
	1012	Statement stmt = conn.createStatement();
	1013	ResultSet results = stmt.executeQuery("SELECT * FROM sample"))
	1014	{
	1015	// header is now treated as normal data line
	1016	results.next();
	1017	assertTrue("Incorrect COLUMN1 Value", results.getString("COLUMN1")
	1018	.equals("ID"));
	1019	assertTrue("Incorrect COLUMN2 Value", results.getString("COLUMN2")
	1020	.equals("NAME"));
	1021	assertTrue("Incorrect COLUMN3 Value", results.getString("COLUMN3")
	1022	.equals("EXTRA_FIELD"));
	1023
	1024	results.next();
	1025	assertTrue("Incorrect COLUMN1 Value", results.getString("COLUMN1")
	1026	.equals("Q123"));
	1027	assertTrue("Incorrect COLUMN2 Value", results.getString("COLUMN2")
	1028	.equals("\"S,\""));
	1029	assertTrue("Incorrect COLUMN3 Value", results.getString("COLUMN3")
	1030	.equals("F"));
	1031
	1032	results.next();
	1033	assertTrue("Incorrect COLUMN1 Value", results.getString("COLUMN1")
	1034	.equals("A123"));
	1035	assertTrue("Incorrect COLUMN2 Value", results.getString("COLUMN2")
	1036	.equals("Jonathan Ackerman"));
	1037	assertTrue("Incorrect COLUMN3 Value", results.getString("COLUMN3")
	1038	.equals("A"));
	1039
	1040	results.next();
	1041	assertTrue("Incorrect COLUMN1 Value", results.getString("COLUMN1")
	1042	.equals("B234"));
	1043	assertTrue("Incorrect COLUMN2 Value", results.getString("COLUMN2")
	1044	.equals("Grady O'Neil"));
	1045	assertTrue("Incorrect COLUMN3 Value", results.getString("COLUMN3")
	1046	.equals("B"));
	1047
	1048	results.next();
	1049	assertTrue("Incorrect COLUMN1 Value", results.getString("COLUMN1")
	1050	.equals("C456"));
	1051	assertTrue("Incorrect COLUMN2 Value", results.getString("COLUMN2")
	1052	.equals("Susan, Peter and Dave"));
	1053	assertTrue("Incorrect COLUMN3 Value", results.getString("COLUMN3")
	1054	.equals("C"));
	1055
	1056	results.next();
	1057	assertTrue("Incorrect COLUMN1 Value", results.getString("COLUMN1")
	1058	.equals("D789"));
	1059	assertTrue("Incorrect COLUMN2 Value", results.getString("COLUMN2")
	1060	.equals("Amelia \"meals\" Maurice"));
	1061	assertTrue("Incorrect COLUMN3 Value", results.getString("COLUMN3")
	1062	.equals("E"));
	1063
	1064	results.next();
	1065	assertTrue("Incorrect COLUMN1 Value", results.getString("COLUMN1")
	1066	.equals("X234"));
	1067	assertTrue("Incorrect COLUMN2 Value", results.getString("COLUMN2")
	1068	.equals("Peter \"peg leg\", Jimmy & Samantha \"Sam\""));
	1069	assertTrue("Incorrect COLUMN3 Value", results.getString("COLUMN3")
	1070	.equals("G"));
	1071	}
1061	1072	}
1062	1073
1063	1074	@Test

1067	1078	props.put("suppressHeaders", "true");
1068	1079	props.put("fileExtension", ".txt");
1069	1080
1070		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
1071		+ filePath, props);
1072
1073		Statement stmt = conn.createStatement();
1074
1075		ResultSet results = stmt.executeQuery("SELECT * FROM embassies");
1076
1077		// Test selecting from a file with a multi-line value as the first record.
1078		assertTrue(results.next());
1079		assertEquals("Incorrect COLUMN1 Value", "Germany", results.getString("COLUMN1"));
1080		assertEquals("Incorrect COLUMN2 Value", "Wallstrasse 76-79,\n10179 Berlin", results.getString("COLUMN2"));
1081		assertTrue(results.next());
	1081	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	1082	+ filePath, props);
	1083
	1084	Statement stmt = conn.createStatement();
	1085
	1086	ResultSet results = stmt.executeQuery("SELECT * FROM embassies"))
	1087	{
	1088	// Test selecting from a file with a multi-line value as the first record.
	1089	assertTrue(results.next());
	1090	assertEquals("Incorrect COLUMN1 Value", "Germany", results.getString("COLUMN1"));
	1091	assertEquals("Incorrect COLUMN2 Value", "Wallstrasse 76-79,\n10179 Berlin", results.getString("COLUMN2"));
	1092	assertTrue(results.next());
	1093	}
1082	1094	}
1083	1095
1084	1096	@Test

1088	1100	String parentPath = new File(filePath).getParent();
1089	1101	String subPath = new File(filePath).getName();
1090	1102
1091		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	1103	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
1092	1104	+ parentPath);
1093	1105
1094	1106	Statement stmt = conn.createStatement();
1095	1107
1096	1108	ResultSet results = stmt
1097	1109	.executeQuery("SELECT NAME,ID,EXTRA_FIELD FROM ."
1098		+ File.separator + subPath + File.separator + "sample");
1099
1100		results.next();
1101		assertTrue("Incorrect ID Value", results.getString("ID").equals("Q123"));
1102		assertTrue("Incorrect NAME Value", results.getString("NAME").equals(
1103		"\"S,\""));
1104		assertTrue("Incorrect EXTRA_FIELD Value", results.getString(
1105		"EXTRA_FIELD").equals("F"));
1106
1107		results.close();
1108		stmt.close();
1109		conn.close();
	1110	+ File.separator + subPath + File.separator + "sample"))
	1111	{
	1112	results.next();
	1113	assertTrue("Incorrect ID Value", results.getString("ID").equals("Q123"));
	1114	assertTrue("Incorrect NAME Value", results.getString("NAME").equals(
	1115	"\"S,\""));
	1116	assertTrue("Incorrect EXTRA_FIELD Value", results.getString(
	1117	"EXTRA_FIELD").equals("F"));
	1118	}
1110	1119	}
1111	1120
1112	1121	@Test
1113	1122	public void testWhereMultipleResult() throws SQLException
1114	1123	{
1115		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	1124	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
1116	1125	+ filePath);
1117	1126
1118		Statement stmt = conn.createStatement();
1119
1120		ResultSet results = stmt
1121		.executeQuery("SELECT ID, Name, Job FROM sample4 WHERE Job = 'Project Manager'");
1122		assertTrue(results.next());
1123		assertEquals("The ID is wrong", "01", results.getString("ID"));
1124		assertTrue(results.next());
1125		assertEquals("The ID is wrong", "02", results.getString("ID"));
1126		assertTrue(results.next());
1127		assertEquals("The ID is wrong", "04", results.getString("ID"));
1128		assertTrue(!results.next());
	1127	Statement stmt = conn.createStatement();
	1128
	1129	ResultSet results = stmt
	1130	.executeQuery("SELECT ID, Name, Job FROM sample4 WHERE Job = 'Project Manager'"))
	1131	{
	1132	assertTrue(results.next());
	1133	assertEquals("The ID is wrong", "01", results.getString("ID"));
	1134	assertTrue(results.next());
	1135	assertEquals("The ID is wrong", "02", results.getString("ID"));
	1136	assertTrue(results.next());
	1137	assertEquals("The ID is wrong", "04", results.getString("ID"));
	1138	assertTrue(!results.next());
	1139	}
1129	1140	}
1130	1141
1131	1142	@Test
1132	1143	public void testFieldAsAlias() throws SQLException
1133	1144	{
1134		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	1145	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
1135	1146	+ filePath);
1136	1147
1137		Statement stmt = conn.createStatement();
1138
1139		//TODO using alias j in the WHERE clause is not valid SQL. Should we really test this?
1140		ResultSet results = stmt
1141		.executeQuery("SELECT ID as i, Name as n, Job as j FROM sample4 WHERE j='Project Manager'");
1142		assertTrue(results.next());
1143		assertEquals("The ID is wrong", "01", results.getString("i"));
1144		assertTrue(results.next());
1145		assertEquals("The ID is wrong", "02", results.getString("i"));
1146		assertEquals("The name is wrong", "Mauricio Hernandez", results
1147		.getString("N"));
1148		assertEquals("The name is wrong", "Mauricio Hernandez", results
1149		.getString(2));
1150		assertEquals("The job is wrong", "Project Manager", results
1151		.getString("J"));
1152		assertTrue(results.next());
1153		assertEquals("The ID is wrong", "04", results.getString("i"));
1154		assertTrue(!results.next());
	1148	Statement stmt = conn.createStatement();
	1149
	1150	//TODO using alias j in the WHERE clause is not valid SQL. Should we really test this?
	1151	ResultSet results = stmt
	1152	.executeQuery("SELECT ID as i, Name as n, Job as j FROM sample4 WHERE j='Project Manager'"))
	1153	{
	1154	assertTrue(results.next());
	1155	assertEquals("The ID is wrong", "01", results.getString("i"));
	1156	assertTrue(results.next());
	1157	assertEquals("The ID is wrong", "02", results.getString("i"));
	1158	assertEquals("The name is wrong", "Mauricio Hernandez", results
	1159	.getString("N"));
	1160	assertEquals("The name is wrong", "Mauricio Hernandez", results
	1161	.getString(2));
	1162	assertEquals("The job is wrong", "Project Manager", results
	1163	.getString("J"));
	1164	assertTrue(results.next());
	1165	assertEquals("The ID is wrong", "04", results.getString("i"));
	1166	assertTrue(!results.next());
	1167	}
1155	1168	}
1156	1169
1157	1170	@Test
1158	1171	public void testSelectStar() throws SQLException
1159	1172	{
1160		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	1173	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
1161	1174	+ filePath);
1162	1175
1163		Statement stmt = conn.createStatement();
1164
1165		CsvResultSet results = (CsvResultSet) stmt
1166		.executeQuery("SELECT * FROM sample4");
1167		assertEquals("ID", results.getMetaData().getColumnName(1).toString());
1168		assertEquals("ID", results.getMetaData().getColumnLabel(1).toString());
1169
1170		assertTrue(results.next());
1171		assertEquals("The ID is wrong", "01", results.getString("id"));
1172		assertTrue(results.next());
1173		assertEquals("The ID is wrong", "02", results.getString("id"));
1174		assertEquals("The name is wrong", "Mauricio Hernandez", results
1175		.getString("Name"));
1176		assertEquals("The name is wrong", "Mauricio Hernandez", results
1177		.getString(2));
1178		assertEquals("The job is wrong", "Project Manager", results
1179		.getString("Job"));
1180		assertTrue(results.next());
1181		assertTrue(results.next());
1182		assertEquals("The ID is wrong", "04", results.getString("id"));
1183		assertTrue(!results.next());
	1176	Statement stmt = conn.createStatement();
	1177
	1178	CsvResultSet results = (CsvResultSet) stmt
	1179	.executeQuery("SELECT * FROM sample4"))
	1180	{
	1181	assertEquals("ID", results.getMetaData().getColumnName(1).toString());
	1182	assertEquals("ID", results.getMetaData().getColumnLabel(1).toString());
	1183
	1184	assertTrue(results.next());
	1185	assertEquals("The ID is wrong", "01", results.getString("id"));
	1186	assertTrue(results.next());
	1187	assertEquals("The ID is wrong", "02", results.getString("id"));
	1188	assertEquals("The name is wrong", "Mauricio Hernandez", results
	1189	.getString("Name"));
	1190	assertEquals("The name is wrong", "Mauricio Hernandez", results
	1191	.getString(2));
	1192	assertEquals("The job is wrong", "Project Manager", results
	1193	.getString("Job"));
	1194	assertTrue(results.next());
	1195	assertTrue(results.next());
	1196	assertEquals("The ID is wrong", "04", results.getString("id"));
	1197	assertTrue(!results.next());
	1198	}
1184	1199	}
1185	1200
1186	1201	@Test
1187	1202	public void testSelectNull() throws SQLException
1188	1203	{
1189		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	1204	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
1190	1205	+ filePath);
1191	1206
1192		Statement stmt = conn.createStatement();
1193
1194		ResultSet results = stmt
1195		.executeQuery("SELECT ID, null as ID2 FROM sample4");
1196		assertEquals("ID2", results.getMetaData().getColumnName(2));
1197		assertTrue(results.next());
1198		assertEquals("The ID2 is wrong", null, results.getString("id2"));
1199		assertTrue(results.next());
1200		assertEquals("The ID2 is wrong", null, results.getObject("id2"));
	1207	Statement stmt = conn.createStatement();
	1208
	1209	ResultSet results = stmt
	1210	.executeQuery("SELECT ID, null as ID2 FROM sample4"))
	1211	{
	1212	assertEquals("ID2", results.getMetaData().getColumnName(2));
	1213	assertTrue(results.next());
	1214	assertEquals("The ID2 is wrong", null, results.getString("id2"));
	1215	assertTrue(results.next());
	1216	assertEquals("The ID2 is wrong", null, results.getObject("id2"));
	1217	}
1201	1218	}
1202	1219
1203	1220	@Test
1204	1221	public void testLiteralAsAlias() throws SQLException
1205	1222	{
1206		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	1223	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
1207	1224	+ filePath);
1208	1225
1209		Statement stmt = conn.createStatement();
1210
1211		ResultSet results = stmt
1212		.executeQuery("SELECT Job j,ID i,Name n, 0 c FROM sample4");
1213		assertTrue("no results found - should be all", results.next());
1214		assertTrue("no results found - should be all", results.next());
1215		assertEquals("The literal c is wrong", "0", results.getString("c"));
1216		assertEquals("The literal c is wrong", "0", results.getString(4));
1217		assertEquals("The name is wrong", "Mauricio Hernandez", results
1218		.getString("N"));
1219		assertEquals("The job is wrong", "Project Manager", results
1220		.getString("J"));
	1226	Statement stmt = conn.createStatement();
	1227
	1228	ResultSet results = stmt
	1229	.executeQuery("SELECT Job j,ID i,Name n, 0 c FROM sample4"))
	1230	{
	1231	assertTrue("no results found - should be all", results.next());
	1232	assertTrue("no results found - should be all", results.next());
	1233	assertEquals("The literal c is wrong", "0", results.getString("c"));
	1234	assertEquals("The literal c is wrong", "0", results.getString(4));
	1235	assertEquals("The name is wrong", "Mauricio Hernandez", results
	1236	.getString("N"));
	1237	assertEquals("The job is wrong", "Project Manager", results
	1238	.getString("J"));
	1239	}
1221	1240	}
1222	1241
1223	1242	@Test

1225	1244	{
1226	1245	Properties props = new Properties();
1227	1246	props.put("columnTypes", "Int,String,String");
1228		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
1229		+ filePath, props);
1230
1231		Statement stmt = conn.createStatement();
1232
1233		ResultSet results = stmt
1234		.executeQuery("SELECT 44, lower(job), ID*2, 'hello', 44 from sample4");
1235		assertTrue("no results found", results.next());
1236		assertEquals("Number 44 is wrong", 44, results.getInt(1));
1237		assertEquals("lower(job) is wrong", "project manager", results.getString(2));
1238		assertEquals("ID*2 is wrong", 2, results.getInt(3));
1239		assertEquals("String 'hello' is wrong", "hello", results.getString(4));
1240		assertEquals("Number 44 is wrong", 44, results.getInt(5));
	1247
	1248	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	1249	+ filePath, props);
	1250
	1251	Statement stmt = conn.createStatement();
	1252
	1253	ResultSet results = stmt
	1254	.executeQuery("SELECT 44, lower(job), ID*2, 'hello', 44 from sample4"))
	1255	{
	1256	assertTrue("no results found", results.next());
	1257	assertEquals("Number 44 is wrong", 44, results.getInt(1));
	1258	assertEquals("lower(job) is wrong", "project manager", results.getString(2));
	1259	assertEquals("ID*2 is wrong", 2, results.getInt(3));
	1260	assertEquals("String 'hello' is wrong", "hello", results.getString(4));
	1261	assertEquals("Number 44 is wrong", 44, results.getInt(5));
	1262	}
1241	1263	}
1242	1264
1243	1265	/**
1244	1266	* This returns no results with where and tests if this still works
1245		*
	1267	*
1246	1268	* @throws SQLException
1247	1269	*/
1248	1270	@Test
1249	1271	public void testWhereNoResults() throws SQLException
1250	1272	{
1251		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	1273	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
1252	1274	+ filePath);
1253		Statement stmt = conn.createStatement();
1254		ResultSet results = stmt
1255		.executeQuery("SELECT ID,Name FROM sample4 WHERE ID='05'");
1256		assertFalse(results.next());
	1275	Statement stmt = conn.createStatement();
	1276	ResultSet results = stmt
	1277	.executeQuery("SELECT ID,Name FROM sample4 WHERE ID='05'"))
	1278	{
	1279	assertFalse(results.next());
	1280	}
1257	1281	}
1258	1282
1259	1283	@Test
1260	1284	public void testSelectStarWhereMultipleResult() throws SQLException
1261	1285	{
1262		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	1286	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
1263	1287	+ filePath);
1264	1288
1265		Statement stmt = conn.createStatement();
1266
1267		ResultSet results = stmt
1268		.executeQuery("SELECT * FROM sample4 WHERE Job = 'Project Manager'");
1269		assertTrue(results.next());
1270		assertEquals("The ID is wrong", "01", results.getString("ID"));
1271		assertTrue(results.next());
1272		assertEquals("The ID is wrong", "02", results.getString("ID"));
1273		assertTrue(results.next());
1274		assertEquals("The ID is wrong", "04", results.getString("ID"));
1275		assertTrue(!results.next());
	1289	Statement stmt = conn.createStatement();
	1290
	1291	ResultSet results = stmt
	1292	.executeQuery("SELECT * FROM sample4 WHERE Job = 'Project Manager'"))
	1293	{
	1294	assertTrue(results.next());
	1295	assertEquals("The ID is wrong", "01", results.getString("ID"));
	1296	assertTrue(results.next());
	1297	assertEquals("The ID is wrong", "02", results.getString("ID"));
	1298	assertTrue(results.next());
	1299	assertEquals("The ID is wrong", "04", results.getString("ID"));
	1300	assertTrue(!results.next());
	1301	}
1276	1302	}
1277	1303
1278	1304	@Test
1279	1305	public void testSelectStarWithTableAlias() throws SQLException
1280	1306	{
1281		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	1307	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
1282	1308	+ filePath);
1283	1309
1284		Statement stmt = conn.createStatement();
1285
1286		ResultSet results = stmt
1287		.executeQuery("SELECT tbl.* FROM sample4 tbl");
1288		assertTrue(results.next());
1289		assertEquals("The ID is wrong", "01", results.getString("ID"));
1290		assertEquals("The Job is wrong", "Project Manager", results.getString(3));
	1310	Statement stmt = conn.createStatement();
	1311
	1312	ResultSet results = stmt
	1313	.executeQuery("SELECT tbl.* FROM sample4 tbl"))
	1314	{
	1315	assertTrue(results.next());
	1316	assertEquals("The ID is wrong", "01", results.getString("ID"));
	1317	assertEquals("The Job is wrong", "Project Manager", results.getString(3));
	1318	}
1291	1319	}
1292	1320
1293	1321	@Test
1294	1322	public void testWhereWithAndOperator() throws SQLException
1295	1323	{
1296		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	1324	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
1297	1325	+ filePath);
1298	1326
1299		Statement stmt = conn.createStatement();
1300
1301		ResultSet results = stmt
1302		.executeQuery("SELECT * FROM sample4 WHERE Job = 'Project Manager' AND Name = 'Mauricio Hernandez'");
1303		assertTrue(results.next());
1304		assertEquals("The ID is wrong", "02", results.getString("ID"));
1305		assertTrue(!results.next());
	1327	Statement stmt = conn.createStatement();
	1328
	1329	ResultSet results = stmt
	1330	.executeQuery("SELECT * FROM sample4 WHERE Job = 'Project Manager' AND Name = 'Mauricio Hernandez'"))
	1331	{
	1332	assertTrue(results.next());
	1333	assertEquals("The ID is wrong", "02", results.getString("ID"));
	1334	assertTrue(!results.next());
	1335	}
1306	1336	}
1307	1337
1308	1338	@Test
1309	1339	public void testWhereWithBetweenOperator() throws SQLException
1310	1340	{
1311		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	1341	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
1312	1342	+ filePath);
1313	1343
1314		Statement stmt = conn.createStatement();
1315
1316		ResultSet results = stmt
1317		.executeQuery("SELECT * FROM sample4 WHERE id BETWEEN '02' AND '03'");
1318
1319		assertTrue(results.next());
1320		assertEquals("The ID is wrong", 2, results.getInt("ID"));
1321		assertTrue(results.next());
1322		assertEquals("The ID is wrong", 3, results.getInt("ID"));
1323		assertTrue(!results.next());
	1344	Statement stmt = conn.createStatement();
	1345
	1346	ResultSet results = stmt
	1347	.executeQuery("SELECT * FROM sample4 WHERE id BETWEEN '02' AND '03'"))
	1348	{
	1349	assertTrue(results.next());
	1350	assertEquals("The ID is wrong", 2, results.getInt("ID"));
	1351	assertTrue(results.next());
	1352	assertEquals("The ID is wrong", 3, results.getInt("ID"));
	1353	assertTrue(!results.next());
	1354	}
1324	1355	}
1325	1356
1326	1357	@Test

1330	1361	props.put("columnTypes", "Int,Int,Int,Date,Time");
1331	1362	props.put("dateFormat", "M/D/YYYY");
1332	1363
1333		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
1334		+ filePath, props);
1335
1336		Statement stmt = conn.createStatement();
1337
1338		ResultSet results = stmt
1339		.executeQuery("SELECT * FROM Purchase WHERE PurchaseDate BETWEEN '1/11/2013' AND '1/15/2013'");
1340
1341		assertTrue(results.next());
1342		assertEquals("The AccountNo is wrong", 58375, results.getInt("AccountNo"));
1343		assertTrue(results.next());
1344		assertEquals("The AccountNo is wrong", 34625, results.getInt("AccountNo"));
1345		assertTrue(results.next());
1346		assertEquals("The AccountNo is wrong", 34771, results.getInt("AccountNo"));
1347		assertTrue(!results.next());
	1364	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	1365	+ filePath, props);
	1366
	1367	Statement stmt = conn.createStatement();
	1368
	1369	ResultSet results = stmt
	1370	.executeQuery("SELECT * FROM Purchase WHERE PurchaseDate BETWEEN '1/11/2013' AND '1/15/2013'"))
	1371	{
	1372	assertTrue(results.next());
	1373	assertEquals("The AccountNo is wrong", 58375, results.getInt("AccountNo"));
	1374	assertTrue(results.next());
	1375	assertEquals("The AccountNo is wrong", 34625, results.getInt("AccountNo"));
	1376	assertTrue(results.next());
	1377	assertEquals("The AccountNo is wrong", 34771, results.getInt("AccountNo"));
	1378	assertTrue(!results.next());
	1379	}
1348	1380	}
1349	1381
1350	1382	@Test

1354	1386	props.put("columnTypes", "Int,Int,Int,Date,Time");
1355	1387	props.put("dateFormat", "M/D/YYYY");
1356	1388
1357		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
1358		+ filePath, props);
1359
1360		Statement stmt = conn.createStatement();
1361
1362		ResultSet results = stmt
1363		.executeQuery("SELECT * FROM Purchase WHERE PurchaseTime BETWEEN '08:30:00' AND '10:00:00'");
1364
1365		assertTrue(results.next());
1366		assertEquals("The AccountNo is wrong", 51002, results.getInt("AccountNo"));
1367		assertFalse(results.next());
	1389	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	1390	+ filePath, props);
	1391
	1392	Statement stmt = conn.createStatement();
	1393
	1394	ResultSet results = stmt
	1395	.executeQuery("SELECT * FROM Purchase WHERE PurchaseTime BETWEEN '08:30:00' AND '10:00:00'"))
	1396	{
	1397	assertTrue(results.next());
	1398	assertEquals("The AccountNo is wrong", 51002, results.getInt("AccountNo"));
	1399	assertFalse(results.next());
	1400	}
1368	1401	}
1369	1402
1370	1403	@Test

1374	1407	props.put("columnTypes", "Integer,String,String,Timestamp,Time");
1375	1408	props.put("charset", "UTF-8");
1376	1409
1377		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
1378		+ filePath, props);
1379
1380		Statement stmt = conn.createStatement();
1381
1382		ResultSet results = stmt
1383		.executeQuery("SELECT * FROM sample5 WHERE Start BETWEEN '2003-03-01 08:30:00' AND '2003-03-02 17:30:00'");
1384
1385		assertTrue(results.next());
1386		assertEquals("The ID is wrong", 3, results.getInt("ID"));
1387		assertFalse(results.next());
	1410	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	1411	+ filePath, props);
	1412
	1413	Statement stmt = conn.createStatement();
	1414
	1415	ResultSet results = stmt
	1416	.executeQuery("SELECT * FROM sample5 WHERE Start BETWEEN '2003-03-01 08:30:00' AND '2003-03-02 17:30:00'"))
	1417	{
	1418	assertTrue(results.next());
	1419	assertEquals("The ID is wrong", 3, results.getInt("ID"));
	1420	assertFalse(results.next());
	1421	}
1388	1422	}
1389	1423
1390	1424	@Test
1391	1425	public void testWhereWithLikeOperatorPercent() throws SQLException
1392	1426	{
1393		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	1427	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
1394	1428	+ filePath);
1395	1429
1396		Statement stmt = conn.createStatement();
1397
1398		ResultSet results = stmt
1399		.executeQuery("SELECT * FROM sample4 WHERE Name LIKE 'Ma%'");
1400
1401		assertTrue(results.next());
1402		assertEquals("The ID is wrong", 2, results.getInt("ID"));
1403		assertTrue(results.next());
1404		assertEquals("The ID is wrong", 3, results.getInt("ID"));
1405		assertFalse(results.next());
	1430	Statement stmt = conn.createStatement();
	1431
	1432	ResultSet results = stmt
	1433	.executeQuery("SELECT * FROM sample4 WHERE Name LIKE 'Ma%'"))
	1434	{
	1435	assertTrue(results.next());
	1436	assertEquals("The ID is wrong", 2, results.getInt("ID"));
	1437	assertTrue(results.next());
	1438	assertEquals("The ID is wrong", 3, results.getInt("ID"));
	1439	assertFalse(results.next());
	1440	}
1406	1441	}
1407	1442
1408	1443	@Test
1409	1444	public void testWhereWithLikeOperatorUnderscore() throws SQLException
1410	1445	{
1411		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	1446	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
1412	1447	+ filePath);
1413	1448
1414		Statement stmt = conn.createStatement();
1415
1416		ResultSet results = stmt
1417		.executeQuery("select id from sample where id like '_234'");
1418
1419		assertTrue(results.next());
1420		assertEquals("The ID is wrong", "B234", results.getString("ID"));
1421		assertTrue(results.next());
1422		assertEquals("The ID is wrong", "X234", results.getString("ID"));
1423		assertFalse(results.next());
	1449	Statement stmt = conn.createStatement();
	1450
	1451	ResultSet results = stmt
	1452	.executeQuery("select id from sample where id like '_234'"))
	1453	{
	1454	assertTrue(results.next());
	1455	assertEquals("The ID is wrong", "B234", results.getString("ID"));
	1456	assertTrue(results.next());
	1457	assertEquals("The ID is wrong", "X234", results.getString("ID"));
	1458	assertFalse(results.next());
	1459	}
1424	1460	}
1425	1461
1426	1462	@Test
1427	1463	public void testWhereWithLikeOperatorEscape() throws SQLException
1428	1464	{
1429		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	1465	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
1430	1466	+ filePath);
1431	1467
1432		Statement stmt = conn.createStatement();
1433
1434		ResultSet results = stmt
1435		.executeQuery("select ID from escape where ID like 'index\\__'");
1436
1437		assertTrue(results.next());
1438		assertEquals("The ID is wrong", "index_1", results.getString("ID"));
1439		assertTrue(results.next());
1440		assertEquals("The ID is wrong", "index_2", results.getString("ID"));
1441		assertTrue(results.next());
1442		assertEquals("The ID is wrong", "index_3", results.getString("ID"));
1443		assertFalse(results.next());
1444
1445		ResultSet results2 = stmt
1446		.executeQuery("select ID from escape where ID like 'index^__' escape '^'");
1447
1448		assertTrue(results2.next());
1449		assertEquals("The ID is wrong", "index_1", results2.getString("ID"));
1450		assertTrue(results2.next());
1451		assertEquals("The ID is wrong", "index_2", results2.getString("ID"));
1452		assertTrue(results2.next());
1453		assertEquals("The ID is wrong", "index_3", results2.getString("ID"));
1454		assertFalse(results2.next());
1455
1456		ResultSet results3 = stmt
1457		.executeQuery("select ID from escape where ID like 'index^%%' escape '^'");
1458
1459		assertTrue(results3.next());
1460		assertEquals("The ID is wrong", "index%%", results3.getString("ID"));
1461		assertTrue(results3.next());
1462		assertEquals("The ID is wrong", "index%3", results3.getString("ID"));
1463		assertFalse(results3.next());
	1468	Statement stmt = conn.createStatement())
	1469	{
	1470	try (ResultSet results = stmt
	1471	.executeQuery("select ID from escape where ID like 'index\\__'"))
	1472	{
	1473	assertTrue(results.next());
	1474	assertEquals("The ID is wrong", "index_1", results.getString("ID"));
	1475	assertTrue(results.next());
	1476	assertEquals("The ID is wrong", "index_2", results.getString("ID"));
	1477	assertTrue(results.next());
	1478	assertEquals("The ID is wrong", "index_3", results.getString("ID"));
	1479	assertFalse(results.next());
	1480	}
	1481
	1482	try (ResultSet results2 = stmt
	1483	.executeQuery("select ID from escape where ID like 'index^__' escape '^'"))
	1484	{
	1485	assertTrue(results2.next());
	1486	assertEquals("The ID is wrong", "index_1", results2.getString("ID"));
	1487	assertTrue(results2.next());
	1488	assertEquals("The ID is wrong", "index_2", results2.getString("ID"));
	1489	assertTrue(results2.next());
	1490	assertEquals("The ID is wrong", "index_3", results2.getString("ID"));
	1491	assertFalse(results2.next());
	1492	}
	1493
	1494	try (ResultSet results3 = stmt
	1495	.executeQuery("select ID from escape where ID like 'index^%%' escape '^'"))
	1496	{
	1497	assertTrue(results3.next());
	1498	assertEquals("The ID is wrong", "index%%", results3.getString("ID"));
	1499	assertTrue(results3.next());
	1500	assertEquals("The ID is wrong", "index%3", results3.getString("ID"));
	1501	assertFalse(results3.next());
	1502	}
	1503	}
1464	1504	}
1465	1505
1466	1506	@Test
1467	1507	public void testWhereWithLikeMultiLine() throws SQLException
1468	1508	{
1469		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	1509	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
1470	1510	+ filePath);
1471	1511
1472		Statement stmt = conn.createStatement();
1473
1474		ResultSet results = stmt
1475		.executeQuery("select N from nikesh where Message like '%SSL%'");
1476
1477		assertTrue(results.next());
1478		assertEquals("N is wrong", 1, results.getInt(1));
1479		assertTrue(results.next());
1480		assertEquals("N is wrong", 2, results.getInt(1));
1481		assertTrue(results.next());
1482		assertEquals("N is wrong", 4, results.getInt(1));
1483		assertFalse(results.next());
	1512	Statement stmt = conn.createStatement();
	1513
	1514	ResultSet results = stmt
	1515	.executeQuery("select N from nikesh where Message like '%SSL%'"))
	1516	{
	1517	assertTrue(results.next());
	1518	assertEquals("N is wrong", 1, results.getInt(1));
	1519	assertTrue(results.next());
	1520	assertEquals("N is wrong", 2, results.getInt(1));
	1521	assertTrue(results.next());
	1522	assertEquals("N is wrong", 4, results.getInt(1));
	1523	assertFalse(results.next());
	1524	}
1484	1525	}
1485	1526
1486	1527	@Test
1487	1528	public void testWhereWithUnselectedColumn() throws SQLException
1488	1529	{
1489		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	1530	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
1490	1531	+ filePath);
1491	1532
1492		Statement stmt = conn.createStatement();
1493
1494		ResultSet results = stmt
1495		.executeQuery("SELECT Name, Job FROM sample4 WHERE id = '04'");
1496		assertTrue(results.next());
	1533	Statement stmt = conn.createStatement();
	1534
	1535	ResultSet results = stmt
	1536	.executeQuery("SELECT Name, Job FROM sample4 WHERE id = '04'"))
	1537	{
	1538	assertTrue(results.next());
	1539	try
	1540	{
	1541	results.getString("id");
	1542	fail("Should not find the column 'id'");
	1543	}
	1544	catch (SQLException e)
	1545	{
	1546	assertEquals("java.sql.SQLException: " + CsvResources.getString("invalidColumnName") + ": id", "" + e);
	1547	}
	1548	assertEquals("The name is wrong", "Felipe Grajales", results
	1549	.getString("name"));
	1550	assertTrue(!results.next());
	1551	}
	1552	}
	1553
	1554	@Test
	1555	public void testWhereWithBadColumnName() throws SQLException
	1556	{
1497	1557	try
1498	1558	{
1499		results.getString("id");
1500		fail("Should not find the column 'id'");
	1559	Properties props = new Properties();
	1560	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	1561	+ filePath, props);
	1562
	1563	Statement stmt = conn.createStatement())
	1564	{
	1565	stmt.executeQuery("SELECT Id FROM sample where XXXX='123'");
	1566	fail("Should raise a java.sqlSQLException");
	1567	}
1501	1568	}
1502	1569	catch (SQLException e)
1503	1570	{
1504		assertEquals("java.sql.SQLException: " + CsvResources.getString("invalidColumnName") + ": id", "" + e);
1505		}
1506		assertEquals("The name is wrong", "Felipe Grajales", results
1507		.getString("name"));
1508		assertTrue(!results.next());
1509		}
1510
1511		@Test
1512		public void testWhereWithBadColumnName() throws SQLException
1513		{
1514		try
1515		{
1516		Properties props = new Properties();
1517		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
1518		+ filePath, props);
1519
1520		Statement stmt = conn.createStatement();
1521
1522		stmt.executeQuery("SELECT Id FROM sample where XXXX='123'");
1523		fail("Should raise a java.sqlSQLException");
1524		}
1525		catch (SQLException e)
1526		{
1527	1571	assertEquals("java.sql.SQLException: " + CsvResources.getString("invalidColumnName") + ": XXXX", "" + e);
1528	1572	}
1529	1573	}

1533	1577	{
1534	1578	Properties props = new Properties();
1535	1579	props.put("columnTypes", "Double");
1536		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
1537		+ filePath, props);
1538
1539		Statement stmt = conn.createStatement();
1540
1541		ResultSet results = stmt
1542		.executeQuery("SELECT c4 FROM numeric WHERE c4 >= 2.00e+6 and c4 <= 9e15 and c1 < 1.e-1");
1543		assertTrue(results.next());
1544
1545		double d = results.getDouble("c4");
1546		long l = Math.round(d);
1547		assertEquals("The c4 is wrong", l, 990000000000l);
1548		assertFalse(results.next());
	1580
	1581	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	1582	+ filePath, props);
	1583
	1584	Statement stmt = conn.createStatement();
	1585
	1586	ResultSet results = stmt
	1587	.executeQuery("SELECT c4 FROM numeric WHERE c4 >= 2.00e+6 and c4 <= 9e15 and c1 < 1.e-1"))
	1588	{
	1589	assertTrue(results.next());
	1590
	1591	double d = results.getDouble("c4");
	1592	long l = Math.round(d);
	1593	assertEquals("The c4 is wrong", l, 990000000000l);
	1594	assertFalse(results.next());
	1595	}
1549	1596	}
1550	1597
1551	1598	@Test

1554	1601	Properties props = new Properties();
1555	1602	props.put("columnTypes", "Int,String,Date,Time");
1556	1603	props.put("dateFormat", "yyyy-MM-dd");
1557		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
1558		+ filePath, props);
1559
1560		Statement stmt = conn.createStatement();
1561
1562		ResultSet results = stmt.executeQuery("SELECT ID from sample8 where d = '2010-02-02'");
1563		assertTrue(results.next());
1564		assertEquals("The ID is wrong", 2, results.getInt(1));
1565		assertFalse(results.next());
1566
1567		results = stmt.executeQuery("SELECT ID from sample8 where '2010-03-24' < d");
1568		assertTrue(results.next());
1569		assertEquals("The ID is wrong", 3, results.getInt(1));
1570		assertTrue(results.next());
1571		assertEquals("The ID is wrong", 6, results.getInt(1));
1572		assertFalse(results.next());
	1604
	1605	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	1606	+ filePath, props);
	1607
	1608	Statement stmt = conn.createStatement())
	1609	{
	1610	try (ResultSet results = stmt.executeQuery("SELECT ID from sample8 where d = '2010-02-02'"))
	1611	{
	1612	assertTrue(results.next());
	1613	assertEquals("The ID is wrong", 2, results.getInt(1));
	1614	assertFalse(results.next());
	1615	}
	1616
	1617	try (ResultSet results = stmt.executeQuery("SELECT ID from sample8 where '2010-03-24' < d"))
	1618	{
	1619	assertTrue(results.next());
	1620	assertEquals("The ID is wrong", 3, results.getInt(1));
	1621	assertTrue(results.next());
	1622	assertEquals("The ID is wrong", 6, results.getInt(1));
	1623	assertFalse(results.next());
	1624	}
	1625	}
1573	1626	}
1574	1627
1575	1628	@Test

1579	1632	props.put("columnTypes", "Int,Int,Int,Date,Time");
1580	1633	props.put("dateFormat", "M/D/YYYY");
1581	1634
1582		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
1583		+ filePath, props);
1584
1585		Statement stmt = conn.createStatement();
1586
1587		ResultSet results = stmt
1588		.executeQuery("SELECT * FROM Purchase WHERE PurchaseTime >= '12:00:00' and '12:59:59' >= PurchaseTime");
1589
1590		assertTrue(results.next());
1591		assertEquals("The AccountNo is wrong", 34771, results.getInt("AccountNo"));
1592		assertFalse(results.next());
	1635	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	1636	+ filePath, props);
	1637
	1638	Statement stmt = conn.createStatement();
	1639
	1640	ResultSet results = stmt
	1641	.executeQuery("SELECT * FROM Purchase WHERE PurchaseTime >= '12:00:00' and '12:59:59' >= PurchaseTime"))
	1642	{
	1643	assertTrue(results.next());
	1644	assertEquals("The AccountNo is wrong", 34771, results.getInt("AccountNo"));
	1645	assertFalse(results.next());
	1646	}
1593	1647	}
1594	1648
1595	1649	@Test

1599	1653	props.put("columnTypes", "Integer,String,String,Timestamp,Time");
1600	1654	props.put("charset", "UTF-8");
1601	1655
1602		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
1603		+ filePath, props);
1604
1605		Statement stmt = conn.createStatement();
1606
1607		ResultSet results = stmt
1608		.executeQuery("SELECT * FROM sample5 WHERE Start >= '2002-01-01 00:00:00' and '2003-12-31 23:59:59' >= Start");
1609
1610		assertTrue(results.next());
1611		assertEquals("The ID is wrong", 2, results.getInt("ID"));
1612		assertTrue(results.next());
1613		assertEquals("The ID is wrong", 3, results.getInt("ID"));
1614		assertFalse(results.next());
	1656	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	1657	+ filePath, props);
	1658
	1659	Statement stmt = conn.createStatement();
	1660
	1661	ResultSet results = stmt
	1662	.executeQuery("SELECT * FROM sample5 WHERE Start >= '2002-01-01 00:00:00' and '2003-12-31 23:59:59' >= Start"))
	1663	{
	1664	assertTrue(results.next());
	1665	assertEquals("The ID is wrong", 2, results.getInt("ID"));
	1666	assertTrue(results.next());
	1667	assertEquals("The ID is wrong", 3, results.getInt("ID"));
	1668	assertFalse(results.next());
	1669	}
1615	1670	}
1616	1671
1617	1672	@Test

1619	1674	{
1620	1675	Properties props = new Properties();
1621	1676	props.put("columnTypes", "Integer,String,String,Timestamp,Time");
1622		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
1623
1624		Statement stmt = conn.createStatement();
1625
1626		ResultSet results = stmt.executeQuery("select Name from sample5 where id in (3, 4, 5)");
1627
1628		assertTrue(results.next());
1629		assertEquals("The Name is wrong", "Maria Cristina Lucero", results.getString("Name"));
1630		assertTrue(results.next());
1631		assertEquals("The Name is wrong", "Felipe Grajales", results.getString("Name"));
1632		assertTrue(results.next());
1633		assertEquals("The Name is wrong", "Melquisedec Rojas Castillo", results.getString("Name"));
1634		assertFalse(results.next());
	1677
	1678	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
	1679
	1680	Statement stmt = conn.createStatement();
	1681
	1682	ResultSet results = stmt.executeQuery("select Name from sample5 where id in (3, 4, 5)"))
	1683	{
	1684	assertTrue(results.next());
	1685	assertEquals("The Name is wrong", "Maria Cristina Lucero", results.getString("Name"));
	1686	assertTrue(results.next());
	1687	assertEquals("The Name is wrong", "Felipe Grajales", results.getString("Name"));
	1688	assertTrue(results.next());
	1689	assertEquals("The Name is wrong", "Melquisedec Rojas Castillo", results.getString("Name"));
	1690	assertFalse(results.next());
	1691	}
1635	1692	}
1636	1693
1637	1694	@Test

1639	1696	{
1640	1697	Properties props = new Properties();
1641	1698	props.put("columnTypes", "Integer,String,String,Timestamp,Time");
1642		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
1643
1644		Statement stmt = conn.createStatement();
1645
1646		ResultSet results = stmt.executeQuery("select Name from sample5 where id in (23, 24, 25)");
1647
1648		assertFalse(results.next());
	1699
	1700	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
	1701
	1702	Statement stmt = conn.createStatement();
	1703
	1704	ResultSet results = stmt.executeQuery("select Name from sample5 where id in (23, 24, 25)"))
	1705	{
	1706	assertFalse(results.next());
	1707	}
1649	1708	}
1650	1709
1651	1710	@Test
1652	1711	public void testWhereWithNotIn() throws SQLException
1653	1712	{
1654		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath);
1655
1656		Statement stmt = conn.createStatement();
1657
1658		ResultSet results = stmt.executeQuery("select Id from sample where Id not in ('A123', 'B234', 'X234')");
1659
1660		assertTrue(results.next());
1661		assertEquals("The Id is wrong", "Q123", results.getString("Id"));
1662		assertTrue(results.next());
1663		assertEquals("The Id is wrong", "C456", results.getString("Id"));
1664		assertTrue(results.next());
1665		assertEquals("The Id is wrong", "D789", results.getString("Id"));
1666		assertFalse(results.next());
	1713	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath);
	1714
	1715	Statement stmt = conn.createStatement();
	1716
	1717	ResultSet results = stmt.executeQuery("select Id from sample where Id not in ('A123', 'B234', 'X234')"))
	1718	{
	1719	assertTrue(results.next());
	1720	assertEquals("The Id is wrong", "Q123", results.getString("Id"));
	1721	assertTrue(results.next());
	1722	assertEquals("The Id is wrong", "C456", results.getString("Id"));
	1723	assertTrue(results.next());
	1724	assertEquals("The Id is wrong", "D789", results.getString("Id"));
	1725	assertFalse(results.next());
	1726	}
1667	1727	}
1668	1728
1669	1729	@Test
1670	1730	public void testWhereWithInEmpty() throws SQLException
1671	1731	{
1672		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath);
1673
1674		Statement stmt = conn.createStatement();
1675
1676		try
1677		{
1678		stmt.executeQuery("select * from sample where Name in ()");
1679		fail("SQL Query should fail");
1680		}
1681		catch (SQLException e)
1682		{
1683		assertTrue(e.getMessage().startsWith(CsvResources.getString("syntaxError")));
	1732	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath);
	1733
	1734	Statement stmt = conn.createStatement())
	1735	{
	1736	try
	1737	{
	1738	stmt.executeQuery("select * from sample where Name in ()");
	1739	fail("SQL Query should fail");
	1740	}
	1741	catch (SQLException e)
	1742	{
	1743	assertTrue(e.getMessage().startsWith(CsvResources.getString("syntaxError")));
	1744	}
1684	1745	}
1685	1746	}
1686	1747

1691	1752	props.put("columnTypes", "Int,Int,Int,Date,Time");
1692	1753	props.put("dateFormat", "M/D/YYYY");
1693	1754
1694		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
1695		+ filePath, props);
1696
1697		Statement stmt = conn.createStatement();
1698
1699		ResultSet results = stmt
1700		.executeQuery("SELECT * FROM Purchase WHERE PurchaseDate IN ('1/9/2013', '1/16/2013')");
1701
1702		assertTrue(results.next());
1703		assertEquals("The AccountNo is wrong", 19685, results.getInt("AccountNo"));
1704		assertTrue(results.next());
1705		assertEquals("The AccountNo is wrong", 51002, results.getInt("AccountNo"));
1706		assertTrue(!results.next());
	1755	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	1756	+ filePath, props);
	1757
	1758	Statement stmt = conn.createStatement();
	1759
	1760	ResultSet results = stmt
	1761	.executeQuery("SELECT * FROM Purchase WHERE PurchaseDate IN ('1/9/2013', '1/16/2013')"))
	1762	{
	1763	assertTrue(results.next());
	1764	assertEquals("The AccountNo is wrong", 19685, results.getInt("AccountNo"));
	1765	assertTrue(results.next());
	1766	assertEquals("The AccountNo is wrong", 51002, results.getInt("AccountNo"));
	1767	assertTrue(!results.next());
	1768	}
1707	1769	}
1708	1770
1709	1771	@Test

1713	1775	props.put("columnTypes", "Int,Int,Int,Date,Time");
1714	1776	props.put("dateFormat", "M/D/YYYY");
1715	1777
1716		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
1717		+ filePath, props);
1718
1719		Statement stmt = conn.createStatement();
1720
1721		ResultSet results = stmt
1722		.executeQuery("SELECT * FROM Purchase WHERE PurchaseTime IN ('10:10:06', '11:10:06')");
1723
1724		assertTrue(results.next());
1725		assertEquals("The AccountNo is wrong", 22021, results.getInt("AccountNo"));
1726		assertFalse(results.next());
	1778	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	1779	+ filePath, props);
	1780
	1781	Statement stmt = conn.createStatement();
	1782
	1783	ResultSet results = stmt
	1784	.executeQuery("SELECT * FROM Purchase WHERE PurchaseTime IN ('10:10:06', '11:10:06')"))
	1785	{
	1786	assertTrue(results.next());
	1787	assertEquals("The AccountNo is wrong", 22021, results.getInt("AccountNo"));
	1788	assertFalse(results.next());
	1789	}
1727	1790	}
1728	1791
1729	1792	@Test

1733	1796	props.put("columnTypes", "Integer,String,String,Timestamp,Time");
1734	1797	props.put("charset", "UTF-8");
1735	1798
1736		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
1737		+ filePath, props);
1738
1739		Statement stmt = conn.createStatement();
1740
1741		// Note that final Timestamp is wrong format.
1742		ResultSet results = stmt
	1799	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	1800	+ filePath, props);
	1801
	1802	Statement stmt = conn.createStatement();
	1803
	1804	// Note that final Timestamp is wrong format.
	1805	ResultSet results = stmt
1743	1806	.executeQuery("SELECT * FROM sample5 " +
1744		"WHERE Start IN ('2002-02-02 12:30:00', '2004-04-02 12:00:00', '2004-04-02')");
1745
1746		assertTrue(results.next());
1747		assertEquals("The ID is wrong", 2, results.getInt("ID"));
1748		assertFalse(results.next());
	1807	"WHERE Start IN ('2002-02-02 12:30:00', '2004-04-02 12:00:00', '2004-04-02')"))
	1808	{
	1809	assertTrue(results.next());
	1810	assertEquals("The ID is wrong", 2, results.getInt("ID"));
	1811	assertFalse(results.next());
	1812	}
1749	1813	}
1750	1814
1751	1815	@Test

1754	1818	Properties props = new Properties();
1755	1819	props.put("fileExtension", ".txt");
1756	1820	props.put("separator", "\t");
1757		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
1758		+ filePath, props);
1759
1760		Statement stmt = conn.createStatement();
1761
1762		ResultSet results = stmt.executeQuery("SELECT * FROM jo");
1763		assertTrue(results.next());
1764		try
1765		{
1766		results.getString("id");
1767		fail("Should not find the column 'id'");
1768		}
1769		catch (SQLException e)
1770		{
1771		assertEquals("java.sql.SQLException: " + CsvResources.getString("invalidColumnName") + ": id", "" + e);
1772		}
1773		assertEquals("The name is wrong", "3", results.getString("rc"));
1774		// would like to test the full_name_nd, but can't insert the Arabic
1775		// string in the code
1776		assertTrue(results.next());
1777		assertEquals("The name is wrong", "3", results.getString("rc"));
1778		assertTrue(results.next());
1779		assertEquals("The name is wrong", "3", results.getString("rc"));
1780		assertEquals("The name is wrong", "Tall Dhayl", results
1781		.getString("full_name_nd"));
	1821
	1822	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	1823	+ filePath, props);
	1824
	1825	Statement stmt = conn.createStatement();
	1826
	1827	ResultSet results = stmt.executeQuery("SELECT * FROM jo"))
	1828	{
	1829	assertTrue(results.next());
	1830	try
	1831	{
	1832	results.getString("id");
	1833	fail("Should not find the column 'id'");
	1834	}
	1835	catch (SQLException e)
	1836	{
	1837	assertEquals("java.sql.SQLException: " + CsvResources.getString("invalidColumnName") + ": id", "" + e);
	1838	}
	1839	assertEquals("The name is wrong", "3", results.getString("rc"));
	1840	// would like to test the full_name_nd, but can't insert the Arabic
	1841	// string in the code
	1842	assertTrue(results.next());
	1843	assertEquals("The name is wrong", "3", results.getString("rc"));
	1844	assertTrue(results.next());
	1845	assertEquals("The name is wrong", "3", results.getString("rc"));
	1846	assertEquals("The name is wrong", "Tall Dhayl", results
	1847	.getString("full_name_nd"));
	1848	}
1782	1849	}
1783	1850
1784	1851	@Test

1786	1853	{
1787	1854	Properties props = new Properties();
1788	1855	props.put("fileExtension", ".txt");
1789		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
1790		+ filePath, props);
1791
1792		Statement stmt = conn.createStatement();
1793
1794		ResultSet results = stmt.executeQuery("SELECT * FROM witheol");
1795		assertTrue(results.next());
1796		assertEquals("The name is wrong", "1", results.getString("key"));
1797		// would like to test the full_name_nd, but can't insert the Arabic
1798		// string in the code
1799		assertTrue(results.next());
1800		assertEquals("The name is wrong", "2", results.getString("key"));
1801		assertTrue(results.next());
1802		assertEquals("The name is wrong", "3", results.getString("key"));
1803		assertEquals("The name is wrong", "123\n456\n789", results
1804		.getString("value"));
1805		assertTrue(!results.next());
	1856
	1857	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	1858	+ filePath, props);
	1859
	1860	Statement stmt = conn.createStatement();
	1861
	1862	ResultSet results = stmt.executeQuery("SELECT * FROM witheol"))
	1863	{
	1864	assertTrue(results.next());
	1865	assertEquals("The name is wrong", "1", results.getString("key"));
	1866	// would like to test the full_name_nd, but can't insert the Arabic
	1867	// string in the code
	1868	assertTrue(results.next());
	1869	assertEquals("The name is wrong", "2", results.getString("key"));
	1870	assertTrue(results.next());
	1871	assertEquals("The name is wrong", "3", results.getString("key"));
	1872	assertEquals("The name is wrong", "123\n456\n789", results
	1873	.getString("value"));
	1874	assertTrue(!results.next());
	1875	}
1806	1876	}
1807	1877
1808	1878	@Test

1811	1881	Properties props = new Properties();
1812	1882	props.put("fileExtension", ".csv");
1813	1883	props.put("separator", ";");
1814		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
1815		+ filePath, props);
1816
1817		Statement stmt = conn.createStatement();
1818
1819		ResultSet results = stmt.executeQuery("SELECT * FROM badquoted");
1820		assertTrue(results.next());
1821		assertEquals("The name is wrong", "Rechtsform unbekannt", results.getString("F2"));
1822		assertTrue(results.next());
1823		assertEquals("The name is wrong", "Rechtsform \nunbekannt", results.getString("F2"));
1824		assertTrue(results.next());
1825		assertEquals("The name is wrong", "Rechtsform unbekannt", results.getString("F2"));
1826		try
1827		{
1828		results.next();
1829		fail("Should raise a java.sqlSQLException");
1830		}
1831		catch (SQLException e)
1832		{
1833		assertEquals("java.sql.SQLException: " + CsvResources.getString("eofInQuotes") + ": 6", "" + e);
	1884
	1885	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	1886	+ filePath, props);
	1887
	1888	Statement stmt = conn.createStatement();
	1889
	1890	ResultSet results = stmt.executeQuery("SELECT * FROM badquoted"))
	1891	{
	1892	assertTrue(results.next());
	1893	assertEquals("The name is wrong", "Rechtsform unbekannt", results.getString("F2"));
	1894	assertTrue(results.next());
	1895	assertEquals("The name is wrong", "Rechtsform \nunbekannt", results.getString("F2"));
	1896	assertTrue(results.next());
	1897	assertEquals("The name is wrong", "Rechtsform unbekannt", results.getString("F2"));
	1898	try
	1899	{
	1900	results.next();
	1901	fail("Should raise a java.sqlSQLException");
	1902	}
	1903	catch (SQLException e)
	1904	{
	1905	assertEquals("java.sql.SQLException: " + CsvResources.getString("eofInQuotes") + ": 6", "" + e);
	1906	}
1834	1907	}
1835	1908	}
1836	1909

1839	1912	{
1840	1913	Properties props = new Properties();
1841	1914	props.put("fileExtension", ".txt");
1842		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
1843		+ filePath, props);
1844
1845		Statement stmt = conn.createStatement();
1846
1847		ResultSet results = stmt
1848		.executeQuery("SELECT datum, tijd, station, ai007.000 as value FROM test-001-20081112");
1849		assertTrue(results.next());
1850		assertEquals("The name is wrong", "20-12-2007", results
1851		.getString("datum"));
1852		assertEquals("The name is wrong", "10:59:00", results.getString("tijd"));
1853		assertEquals("The name is wrong", "007", results.getString("station"));
1854		assertEquals("The name is wrong", "0.0", results.getString("value"));
	1915
	1916	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	1917	+ filePath, props);
	1918
	1919	Statement stmt = conn.createStatement();
	1920
	1921	ResultSet results = stmt
	1922	.executeQuery("SELECT datum, tijd, station, ai007.000 as value FROM test-001-20081112"))
	1923	{
	1924	assertTrue(results.next());
	1925	assertEquals("The name is wrong", "20-12-2007", results
	1926	.getString("datum"));
	1927	assertEquals("The name is wrong", "10:59:00", results.getString("tijd"));
	1928	assertEquals("The name is wrong", "007", results.getString("station"));
	1929	assertEquals("The name is wrong", "0.0", results.getString("value"));
	1930	}
1855	1931	}
1856	1932
1857	1933	/**
1858	1934	* accessing indexed files that do not exist is the same as accessing an
1859	1935	* empty table. no "file not found" error
1860		*
	1936	*
1861	1937	* @throws SQLException
1862	1938	*/
1863	1939	@Test

1868	1944	props.put("fileTailPattern", "-([0-9]{3})-([0-9]{8})");
1869	1945	props.put("fileTailParts", "location,file_date");
1870	1946	props.put("indexedFiles", "True");
1871		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
1872		+ filePath, props);
1873
1874		Statement stmt = conn.createStatement();
1875
1876		ResultSet results = stmt
1877		.executeQuery("SELECT location,station,datum,tijd,file_date FROM test57");
1878
1879		assertFalse(results.next());
	1947
	1948	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	1949	+ filePath, props);
	1950
	1951	Statement stmt = conn.createStatement();
	1952
	1953	ResultSet results = stmt
	1954	.executeQuery("SELECT location,station,datum,tijd,file_date FROM test57"))
	1955	{
	1956	assertFalse(results.next());
	1957	}
1880	1958	}
1881	1959
1882	1960	@Test

1887	1965	props.put("fileTailPattern", "-([0-9]{3})-([0-9]{8})");
1888	1966	props.put("fileTailParts", "location,file_date");
1889	1967	props.put("indexedFiles", "True");
1890		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
1891		+ filePath, props);
1892
1893		Statement stmt = conn.createStatement();
1894
1895		ResultSet results = stmt
1896		.executeQuery("SELECT location,station,datum,tijd,file_date FROM test");
1897
1898		ResultSetMetaData metadata = results.getMetaData();
1899
1900		assertTrue("Incorrect Table Name", metadata.getTableName(0).equals(
1901		"test"));
1902
1903		assertEquals("Incorrect Column Name 1", metadata.getColumnName(1),
1904		"location");
1905		assertEquals("Incorrect Column Name 2", metadata.getColumnName(2),
1906		"Station");
1907		assertEquals("Incorrect Column Name 3", metadata.getColumnName(3),
1908		"Datum");
1909		assertEquals("Incorrect Column Name 4", metadata.getColumnName(4),
1910		"Tijd");
1911
1912		assertTrue(results.next());
1913		for (int i = 1; i < 12; i++)
1914		{
1915		assertTrue(results.next());
1916		}
1917		for (int i = 0; i < 12; i++)
1918		{
1919		assertTrue(results.next());
1920		}
1921		for (int i = 0; i < 12; i++)
1922		{
1923		assertTrue(results.next());
1924		}
1925		for (int i = 0; i < 36; i++)
1926		{
1927		assertTrue(results.next());
1928		}
1929		for (int i = 0; i < 36; i++)
1930		{
1931		assertTrue(results.next());
1932		}
1933		for (int i = 0; i < 36; i++)
1934		{
1935		assertTrue(results.next());
1936		}
1937		assertFalse(results.next());
	1968
	1969	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	1970	+ filePath, props);
	1971
	1972	Statement stmt = conn.createStatement();
	1973
	1974	ResultSet results = stmt
	1975	.executeQuery("SELECT location,station,datum,tijd,file_date FROM test"))
	1976	{
	1977	ResultSetMetaData metadata = results.getMetaData();
	1978
	1979	assertTrue("Incorrect Table Name", metadata.getTableName(0).equals(
	1980	"test"));
	1981
	1982	assertEquals("Incorrect Column Name 1", metadata.getColumnName(1),
	1983	"location");
	1984	assertEquals("Incorrect Column Name 2", metadata.getColumnName(2),
	1985	"Station");
	1986	assertEquals("Incorrect Column Name 3", metadata.getColumnName(3),
	1987	"Datum");
	1988	assertEquals("Incorrect Column Name 4", metadata.getColumnName(4),
	1989	"Tijd");
	1990
	1991	assertTrue(results.next());
	1992	for (int i = 1; i < 12; i++)
	1993	{
	1994	assertTrue(results.next());
	1995	}
	1996	for (int i = 0; i < 12; i++)
	1997	{
	1998	assertTrue(results.next());
	1999	}
	2000	for (int i = 0; i < 12; i++)
	2001	{
	2002	assertTrue(results.next());
	2003	}
	2004	for (int i = 0; i < 36; i++)
	2005	{
	2006	assertTrue(results.next());
	2007	}
	2008	for (int i = 0; i < 36; i++)
	2009	{
	2010	assertTrue(results.next());
	2011	}
	2012	for (int i = 0; i < 36; i++)
	2013	{
	2014	assertTrue(results.next());
	2015	}
	2016	assertFalse(results.next());
	2017	}
1938	2018	}
1939	2019
1940	2020	@Test

1946	2026	props.put("fileTailParts", "location,file_date");
1947	2027	props.put("indexedFiles", "True");
1948	2028	props.put("fileTailPrepend", "True");
1949		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
1950		+ filePath, props);
1951
1952		Statement stmt = conn.createStatement();
1953
1954		ResultSet results = stmt
1955		.executeQuery("SELECT location,file_date,datum,tijd,station FROM test");
1956
1957		ResultSetMetaData metadata = results.getMetaData();
1958
1959		assertTrue("Incorrect Table Name", metadata.getTableName(0).equals(
1960		"test"));
1961
1962		assertEquals("Incorrect Column Name 1", metadata.getColumnName(1),
1963		"location");
1964		assertEquals("Incorrect Column Name 1", metadata.getColumnName(2),
1965		"file_date");
1966		assertEquals("Incorrect Column Name 1", metadata.getColumnName(3),
1967		"Datum");
1968		assertEquals("Incorrect Column Name 2", metadata.getColumnName(4),
1969		"Tijd");
1970		assertEquals("Incorrect Column Name 3", metadata.getColumnName(5),
1971		"Station");
1972
1973		assertTrue(results.next());
1974		for (int i = 1; i < 12; i++)
1975		{
1976		assertTrue(results.next());
1977		}
1978		for (int i = 0; i < 12; i++)
1979		{
1980		assertTrue(results.next());
1981		}
1982		for (int i = 0; i < 12; i++)
1983		{
1984		assertTrue(results.next());
1985		}
1986		for (int i = 0; i < 36; i++)
1987		{
1988		assertTrue(results.next());
1989		}
1990		for (int i = 0; i < 36; i++)
1991		{
1992		assertTrue(results.next());
1993		}
1994		for (int i = 0; i < 36; i++)
1995		{
1996		assertTrue(results.next());
1997		}
1998		assertFalse(results.next());
	2029
	2030	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	2031	+ filePath, props);
	2032
	2033	Statement stmt = conn.createStatement();
	2034
	2035	ResultSet results = stmt
	2036	.executeQuery("SELECT location,file_date,datum,tijd,station FROM test"))
	2037	{
	2038	ResultSetMetaData metadata = results.getMetaData();
	2039
	2040	assertTrue("Incorrect Table Name", metadata.getTableName(0).equals(
	2041	"test"));
	2042
	2043	assertEquals("Incorrect Column Name 1", metadata.getColumnName(1),
	2044	"location");
	2045	assertEquals("Incorrect Column Name 1", metadata.getColumnName(2),
	2046	"file_date");
	2047	assertEquals("Incorrect Column Name 1", metadata.getColumnName(3),
	2048	"Datum");
	2049	assertEquals("Incorrect Column Name 2", metadata.getColumnName(4),
	2050	"Tijd");
	2051	assertEquals("Incorrect Column Name 3", metadata.getColumnName(5),
	2052	"Station");
	2053
	2054	assertTrue(results.next());
	2055	for (int i = 1; i < 12; i++)
	2056	{
	2057	assertTrue(results.next());
	2058	}
	2059	for (int i = 0; i < 12; i++)
	2060	{
	2061	assertTrue(results.next());
	2062	}
	2063	for (int i = 0; i < 12; i++)
	2064	{
	2065	assertTrue(results.next());
	2066	}
	2067	for (int i = 0; i < 36; i++)
	2068	{
	2069	assertTrue(results.next());
	2070	}
	2071	for (int i = 0; i < 36; i++)
	2072	{
	2073	assertTrue(results.next());
	2074	}
	2075	for (int i = 0; i < 36; i++)
	2076	{
	2077	assertTrue(results.next());
	2078	}
	2079	assertFalse(results.next());
	2080	}
1999	2081	}
2000	2082
2001	2083	@Test
2002	2084	public void testNoPatternGroupFromIndexedTable() throws SQLException
2003	2085	{
2004	2086	Properties props = new Properties();
2005		props.put("fileExtension", ".txt");
2006		props.put("commentChar", "#");
2007		props.put("indexedFiles", "true");
2008
2009		// No groups in ()'s used in regular expression
2010		props.put("fileTailPattern", ".*");
2011		props.put("suppressHeaders", "true");
2012		props.put("headerline", "BLZ,BANK_NAME");
2013		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
2014
2015		Statement stmt = conn.createStatement();
2016
2017		ResultSet results = stmt.executeQuery("SELECT * FROM banks");
2018
2019		assertTrue(results.next());
2020		assertEquals("The BLZ is wrong", "10000000", results.getString("BLZ"));
	2087	props.put("fileExtension", ".txt");
	2088	props.put("commentChar", "#");
	2089	props.put("indexedFiles", "true");
	2090
	2091	// No groups in ()'s used in regular expression
	2092	props.put("fileTailPattern", ".*");
	2093	props.put("suppressHeaders", "true");
	2094	props.put("headerline", "BLZ,BANK_NAME");
	2095
	2096	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
	2097
	2098	Statement stmt = conn.createStatement();
	2099
	2100	ResultSet results = stmt.executeQuery("SELECT * FROM banks"))
	2101	{
	2102	assertTrue(results.next());
	2103	assertEquals("The BLZ is wrong", "10000000", results.getString("BLZ"));
	2104	}
2021	2105	}
2022	2106
2023	2107	@Test
2024	2108	public void testAddingFields() throws SQLException
2025	2109	{
2026		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	2110	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
2027	2111	+ filePath);
2028	2112
2029		Statement stmt = conn.createStatement();
2030
2031		ResultSet results = stmt
2032		.executeQuery("SELECT id + ' ' + job as mix FROM sample4");
2033		assertTrue(results.next());
2034		assertEquals("The mix is wrong", "01 Project Manager", results
2035		.getString("mix"));
2036		assertTrue(results.next());
2037		assertEquals("The mix is wrong", "02 Project Manager", results
2038		.getString("mix"));
2039		assertTrue(results.next());
2040		assertEquals("The mix is wrong", "03 Finance Manager", results
2041		.getString("mix"));
2042		assertTrue(results.next());
2043		assertEquals("The mix is wrong", "04 Project Manager", results
2044		.getString("mix"));
2045		assertTrue(!results.next());
	2113	Statement stmt = conn.createStatement();
	2114
	2115	ResultSet results = stmt
	2116	.executeQuery("SELECT id + ' ' + job as mix FROM sample4"))
	2117	{
	2118	assertTrue(results.next());
	2119	assertEquals("The mix is wrong", "01 Project Manager", results
	2120	.getString("mix"));
	2121	assertTrue(results.next());
	2122	assertEquals("The mix is wrong", "02 Project Manager", results
	2123	.getString("mix"));
	2124	assertTrue(results.next());
	2125	assertEquals("The mix is wrong", "03 Finance Manager", results
	2126	.getString("mix"));
	2127	assertTrue(results.next());
	2128	assertEquals("The mix is wrong", "04 Project Manager", results
	2129	.getString("mix"));
	2130	assertTrue(!results.next());
	2131	}
2046	2132	}
2047	2133
2048	2134	@Test

2051	2137	Properties props = new Properties();
2052	2138	props.put("columnTypes", "Int,String,String,Date,Time");
2053	2139	props.put("timeFormat", "HHmm");
2054		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
2055		+ filePath, props);
2056
2057		Object expect;
2058		Statement stmt = conn.createStatement();
2059
2060		ResultSet results = stmt
2061		.executeQuery("SELECT id, timeoffset FROM sample5");
2062
2063		assertTrue(results.next());
2064		expect = java.sql.Time.valueOf("12:30:00");
2065		assertEquals("Time is a Time", expect.getClass(), results.getObject(
2066		"timeoffset").getClass());
2067		assertEquals("Time is a Time", expect, results.getObject("timeoffset"));
2068
2069		assertTrue(results.next());
2070		expect = java.sql.Time.valueOf("12:35:00");
2071		assertEquals("Time is a Time", expect.getClass(), results.getObject(
2072		"timeoffset").getClass());
2073		assertEquals("Time is a Time", expect, results.getObject("timeoffset"));
2074
2075		assertTrue(results.next());
2076		expect = java.sql.Time.valueOf("12:40:00");
2077		assertEquals("Time is a Time", expect.getClass(), results.getObject(
2078		"timeoffset").getClass());
2079		assertEquals("Time is a Time", expect, results.getObject("timeoffset"));
2080
2081		assertTrue(results.next());
2082		expect = java.sql.Time.valueOf("12:45:00");
2083		assertEquals("Time is a Time", expect.getClass(), results.getObject(
2084		"timeoffset").getClass());
2085		assertEquals("Time is a Time", expect, results.getObject("timeoffset"));
2086
2087		assertTrue(results.next());
2088		expect = java.sql.Time.valueOf("01:00:00");
2089		assertEquals("Time is a Time", expect.getClass(), results.getObject(
2090		"timeoffset").getClass());
2091		assertEquals("Time is a Time", expect, results.getObject("timeoffset"));
2092
2093		assertTrue(results.next());
2094		expect = java.sql.Time.valueOf("01:00:00");
2095		assertEquals("Time is a Time", expect.getClass(), results.getObject(
2096		"timeoffset").getClass());
2097		assertEquals("Time is a Time", expect, results.getObject("timeoffset"));
2098
2099		assertTrue(results.next());
2100		expect = java.sql.Time.valueOf("01:00:00");
2101		assertEquals("Time is a Time", expect.getClass(), results.getObject(
2102		"timeoffset").getClass());
2103		assertEquals("Time is a Time", expect, results.getObject("timeoffset"));
2104
2105		assertTrue(results.next());
2106		expect = java.sql.Time.valueOf("00:00:00");
2107		assertEquals("Time is a Time", expect.getClass(), results.getObject(
2108		"timeoffset").getClass());
2109		assertEquals("Time is a Time", expect, results.getObject("timeoffset"));
2110
2111		assertTrue(results.next());
2112		expect = java.sql.Time.valueOf("00:10:00");
2113		assertEquals("Time is a Time", expect.getClass(), results.getObject(
2114		"timeoffset").getClass());
2115		assertEquals("Time is a Time", expect, results.getObject("timeoffset"));
2116
2117		assertTrue(results.next());
2118		expect = java.sql.Time.valueOf("01:23:00");
2119		assertEquals("Time is a Time", expect.getClass(), results.getObject(
2120		"timeoffset").getClass());
2121		assertEquals("Time is a Time", expect, results.getObject("timeoffset"));
2122
2123		assertFalse(results.next());
	2140
	2141	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	2142	+ filePath, props);
	2143
	2144	Statement stmt = conn.createStatement();
	2145
	2146	ResultSet results = stmt
	2147	.executeQuery("SELECT id, timeoffset FROM sample5"))
	2148	{
	2149	assertTrue(results.next());
	2150	Object expect = java.sql.Time.valueOf("12:30:00");
	2151	assertEquals("Time is a Time", expect.getClass(), results.getObject(
	2152	"timeoffset").getClass());
	2153	assertEquals("Time is a Time", expect, results.getObject("timeoffset"));
	2154
	2155	assertTrue(results.next());
	2156	expect = java.sql.Time.valueOf("12:35:00");
	2157	assertEquals("Time is a Time", expect.getClass(), results.getObject(
	2158	"timeoffset").getClass());
	2159	assertEquals("Time is a Time", expect, results.getObject("timeoffset"));
	2160
	2161	assertTrue(results.next());
	2162	expect = java.sql.Time.valueOf("12:40:00");
	2163	assertEquals("Time is a Time", expect.getClass(), results.getObject(
	2164	"timeoffset").getClass());
	2165	assertEquals("Time is a Time", expect, results.getObject("timeoffset"));
	2166
	2167	assertTrue(results.next());
	2168	expect = java.sql.Time.valueOf("12:45:00");
	2169	assertEquals("Time is a Time", expect.getClass(), results.getObject(
	2170	"timeoffset").getClass());
	2171	assertEquals("Time is a Time", expect, results.getObject("timeoffset"));
	2172
	2173	assertTrue(results.next());
	2174	expect = java.sql.Time.valueOf("01:00:00");
	2175	assertEquals("Time is a Time", expect.getClass(), results.getObject(
	2176	"timeoffset").getClass());
	2177	assertEquals("Time is a Time", expect, results.getObject("timeoffset"));
	2178
	2179	assertTrue(results.next());
	2180	expect = java.sql.Time.valueOf("01:00:00");
	2181	assertEquals("Time is a Time", expect.getClass(), results.getObject(
	2182	"timeoffset").getClass());
	2183	assertEquals("Time is a Time", expect, results.getObject("timeoffset"));
	2184
	2185	assertTrue(results.next());
	2186	expect = java.sql.Time.valueOf("01:00:00");
	2187	assertEquals("Time is a Time", expect.getClass(), results.getObject(
	2188	"timeoffset").getClass());
	2189	assertEquals("Time is a Time", expect, results.getObject("timeoffset"));
	2190
	2191	assertTrue(results.next());
	2192	expect = java.sql.Time.valueOf("00:00:00");
	2193	assertEquals("Time is a Time", expect.getClass(), results.getObject(
	2194	"timeoffset").getClass());
	2195	assertEquals("Time is a Time", expect, results.getObject("timeoffset"));
	2196
	2197	assertTrue(results.next());
	2198	expect = java.sql.Time.valueOf("00:10:00");
	2199	assertEquals("Time is a Time", expect.getClass(), results.getObject(
	2200	"timeoffset").getClass());
	2201	assertEquals("Time is a Time", expect, results.getObject("timeoffset"));
	2202
	2203	assertTrue(results.next());
	2204	expect = java.sql.Time.valueOf("01:23:00");
	2205	assertEquals("Time is a Time", expect.getClass(), results.getObject(
	2206	"timeoffset").getClass());
	2207	assertEquals("Time is a Time", expect, results.getObject("timeoffset"));
	2208
	2209	assertFalse(results.next());
	2210	}
2124	2211	}
2125	2212
2126	2213	@Test

2130	2217	props.put("columnTypes", "Int,String,String,Date,Time");
2131	2218	props.put("timeFormat", "HHmm");
2132	2219	props.put("dateFormat", "yyyy-MM-dd");
2133		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
2134		+ filePath, props);
2135
2136		Object expect;
2137		Statement stmt = conn.createStatement();
2138
2139		ResultSet results = stmt
2140		.executeQuery("SELECT id, start, timeoffset, start+timeoffset AS ts FROM sample5 WHERE id=41 OR id=4");
2141
2142		assertTrue(results.next());
2143		expect = java.sql.Date.valueOf("2001-04-02");
2144		assertEquals("Date is a Date", expect.getClass(), results.getObject(
2145		"start").getClass());
2146		assertEquals("Date is a Date", expect, results.getObject("start"));
2147		expect = java.sql.Time.valueOf("12:30:00");
2148		assertEquals("Time is a Time", expect.getClass(), results.getObject(
2149		"timeoffset").getClass());
2150		assertEquals("Time is a Time", expect, results.getObject("timeoffset"));
2151		expect = java.sql.Timestamp.valueOf("2001-04-02 12:30:00");
2152		assertEquals("adding Date to Time", expect.getClass(), results
2153		.getObject("ts").getClass());
2154		assertEquals("adding Date to Time", ((Timestamp) expect).toString(), toUTC
2155		.format(results.getObject("ts")) + ".0");
2156
2157		assertTrue(results.next());
2158		expect = java.sql.Date.valueOf("2004-04-02");
2159		assertEquals("Date is a Date", expect.getClass(), results.getObject(
2160		"start").getClass());
2161		assertEquals("Date is a Date", expect, results.getObject("start"));
2162		expect = java.sql.Time.valueOf("01:00:00");
2163		assertEquals("Time is a Time", expect.getClass(), results.getObject(
2164		"timeoffset").getClass());
2165		assertEquals("Time is a Time", expect, results.getObject("timeoffset"));
2166		expect = java.sql.Timestamp.valueOf("2004-04-02 01:00:00");
2167		assertEquals("adding Date to Time", expect.getClass(), results
2168		.getObject("ts").getClass());
2169		assertEquals("adding Date to Time", ((Timestamp) expect).toString(), toUTC
2170		.format(results.getObject("ts")) + ".0");
2171
2172		assertFalse(results.next());
	2220
	2221	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	2222	+ filePath, props);
	2223
	2224	Statement stmt = conn.createStatement();
	2225
	2226	ResultSet results = stmt
	2227	.executeQuery("SELECT id, start, timeoffset, start+timeoffset AS ts FROM sample5 WHERE id=41 OR id=4"))
	2228	{
	2229	assertTrue(results.next());
	2230	Object expect = java.sql.Date.valueOf("2001-04-02");
	2231	assertEquals("Date is a Date", expect.getClass(), results.getObject(
	2232	"start").getClass());
	2233	assertEquals("Date is a Date", expect, results.getObject("start"));
	2234	expect = java.sql.Time.valueOf("12:30:00");
	2235	assertEquals("Time is a Time", expect.getClass(), results.getObject(
	2236	"timeoffset").getClass());
	2237	assertEquals("Time is a Time", expect, results.getObject("timeoffset"));
	2238	expect = java.sql.Timestamp.valueOf("2001-04-02 12:30:00");
	2239	assertEquals("adding Date to Time", expect.getClass(), results
	2240	.getObject("ts").getClass());
	2241	assertEquals("adding Date to Time", ((Timestamp) expect).toString(), toUTC
	2242	.format(results.getObject("ts")) + ".0");
	2243
	2244	assertTrue(results.next());
	2245	expect = java.sql.Date.valueOf("2004-04-02");
	2246	assertEquals("Date is a Date", expect.getClass(), results.getObject(
	2247	"start").getClass());
	2248	assertEquals("Date is a Date", expect, results.getObject("start"));
	2249	expect = java.sql.Time.valueOf("01:00:00");
	2250	assertEquals("Time is a Time", expect.getClass(), results.getObject(
	2251	"timeoffset").getClass());
	2252	assertEquals("Time is a Time", expect, results.getObject("timeoffset"));
	2253	expect = java.sql.Timestamp.valueOf("2004-04-02 01:00:00");
	2254	assertEquals("adding Date to Time", expect.getClass(), results
	2255	.getObject("ts").getClass());
	2256	assertEquals("adding Date to Time", ((Timestamp) expect).toString(), toUTC
	2257	.format(results.getObject("ts")) + ".0");
	2258
	2259	assertFalse(results.next());
	2260	}
2173	2261	}
2174	2262
2175	2263	@Test

2181	2269	props.put("columnTypes", "Int,String,String,Date,Time");
2182	2270	props.put("timeFormat", "HHmm");
2183	2271	props.put("dateFormat", "yyyy-MM-dd");
2184		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
2185		+ filePath, props);
2186
2187		Object expect;
2188		Statement stmt = conn.createStatement();
2189
2190		ResultSet results = stmt
2191		.executeQuery("SELECT id, start+timeoffset+61000 AS ts, start+timeoffset-61000 AS ts2 FROM sample5 WHERE id=41 OR id=4");
2192
2193		assertTrue(results.next());
2194		expect = java.sql.Timestamp.valueOf("2001-04-02 12:31:01");
2195		assertEquals("adding Date + Time + Int", expect.getClass(), results
2196		.getObject("ts").getClass());
2197		assertEquals("adding Date to Time", ((Timestamp) expect).toString(), toUTC
2198		.format(results.getObject("ts")) + ".0");
2199		expect = java.sql.Timestamp.valueOf("2001-04-02 12:28:59");
2200		assertEquals("adding Date + Time - Int", expect.getClass(), results
2201		.getObject("ts2").getClass());
2202		assertEquals("adding Date to Time", ((Timestamp) expect).toString(), toUTC
2203		.format(results.getObject("ts2")) + ".0");
2204
2205		assertTrue(results.next());
2206		expect = java.sql.Timestamp.valueOf("2004-04-02 01:01:01");
2207		assertEquals("adding Date to Time", expect.getClass(), results
2208		.getObject("ts").getClass());
2209		assertEquals("adding Date to Time", ((Timestamp) expect).toString(), toUTC
2210		.format(results.getObject("ts")) + ".0");
2211		expect = java.sql.Timestamp.valueOf("2004-04-02 00:58:59");
2212		assertEquals("adding Date to Time", expect.getClass(), results
2213		.getObject("ts2").getClass());
2214		assertEquals("adding Date to Time", ((Timestamp) expect).toString(), toUTC
2215		.format(results.getObject("ts2")) + ".0");
2216
2217		assertFalse(results.next());
	2272
	2273	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	2274	+ filePath, props);
	2275
	2276	Statement stmt = conn.createStatement();
	2277
	2278	ResultSet results = stmt
	2279	.executeQuery("SELECT id, start+timeoffset+61000 AS ts, start+timeoffset-61000 AS ts2 FROM sample5 WHERE id=41 OR id=4"))
	2280	{
	2281	assertTrue(results.next());
	2282	Object expect = java.sql.Timestamp.valueOf("2001-04-02 12:31:01");
	2283	assertEquals("adding Date + Time + Int", expect.getClass(), results
	2284	.getObject("ts").getClass());
	2285	assertEquals("adding Date to Time", ((Timestamp) expect).toString(), toUTC
	2286	.format(results.getObject("ts")) + ".0");
	2287	expect = java.sql.Timestamp.valueOf("2001-04-02 12:28:59");
	2288	assertEquals("adding Date + Time - Int", expect.getClass(), results
	2289	.getObject("ts2").getClass());
	2290	assertEquals("adding Date to Time", ((Timestamp) expect).toString(), toUTC
	2291	.format(results.getObject("ts2")) + ".0");
	2292
	2293	assertTrue(results.next());
	2294	expect = java.sql.Timestamp.valueOf("2004-04-02 01:01:01");
	2295	assertEquals("adding Date to Time", expect.getClass(), results
	2296	.getObject("ts").getClass());
	2297	assertEquals("adding Date to Time", ((Timestamp) expect).toString(), toUTC
	2298	.format(results.getObject("ts")) + ".0");
	2299	expect = java.sql.Timestamp.valueOf("2004-04-02 00:58:59");
	2300	assertEquals("adding Date to Time", expect.getClass(), results
	2301	.getObject("ts2").getClass());
	2302	assertEquals("adding Date to Time", ((Timestamp) expect).toString(), toUTC
	2303	.format(results.getObject("ts2")) + ".0");
	2304
	2305	assertFalse(results.next());
	2306	}
2218	2307	}
2219	2308
2220	2309	@Test

2222	2311	{
2223	2312	Properties props = new Properties();
2224	2313	props.put("columnTypes", "Int,String,String,Date,Time");
2225		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
2226		+ filePath, props);
2227
2228		Statement stmt = conn.createStatement();
2229
2230		ResultSet results = stmt
2231		.executeQuery("SELECT 1 + ID * 2 as N1, ID * -3 + 1 as N2, ID+1+2*3+4 as N3 FROM sample5");
2232		assertTrue(results.next());
2233		assertEquals("N1 is wrong", 83, results.getInt("N1"));
2234		assertEquals("N2 is wrong", -122, results.getInt("N2"));
2235		assertEquals("N3 is wrong", 52, results.getInt("N3"));
	2314
	2315	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	2316	+ filePath, props);
	2317
	2318	Statement stmt = conn.createStatement();
	2319
	2320	ResultSet results = stmt
	2321	.executeQuery("SELECT 1 + ID * 2 as N1, ID * -3 + 1 as N2, ID+1+2*3+4 as N3 FROM sample5"))
	2322	{
	2323	assertTrue(results.next());
	2324	assertEquals("N1 is wrong", 83, results.getInt("N1"));
	2325	assertEquals("N2 is wrong", -122, results.getInt("N2"));
	2326	assertEquals("N3 is wrong", 52, results.getInt("N3"));
	2327	}
2236	2328	}
2237	2329
2238	2330	@Test

2240	2332	{
2241	2333	Properties props = new Properties();
2242	2334	props.put("columnTypes", "Int,String,String,Date,Time");
2243		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
2244		+ filePath, props);
2245
2246		Statement stmt = conn.createStatement();
2247
2248		ResultSet results = stmt
2249		.executeQuery("SELECT ( ID + 1 ) as N1, ((ID + 2) * 3) as N2, (3) as N3 FROM sample5 where ( Job = 'Piloto' )");
2250		assertTrue(results.next());
2251		assertEquals("N1 is wrong", 42, results.getInt("N1"));
2252		assertEquals("N2 is wrong", 129, results.getInt("N2"));
2253		assertEquals("N3 is wrong", 3, results.getInt("N3"));
	2335
	2336	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	2337	+ filePath, props);
	2338
	2339	Statement stmt = conn.createStatement();
	2340
	2341	ResultSet results = stmt
	2342	.executeQuery("SELECT ( ID + 1 ) as N1, ((ID + 2) * 3) as N2, (3) as N3 FROM sample5 where ( Job = 'Piloto' )"))
	2343	{
	2344	assertTrue(results.next());
	2345	assertEquals("N1 is wrong", 42, results.getInt("N1"));
	2346	assertEquals("N2 is wrong", 129, results.getInt("N2"));
	2347	assertEquals("N3 is wrong", 3, results.getInt("N3"));
	2348	}
2254	2349	}
2255	2350
2256	2351	@Test

2258	2353	{
2259	2354	Properties props = new Properties();
2260	2355	props.put("columnTypes", "Int,String,String,Date,Time");
2261		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
2262		+ filePath, props);
2263
2264		Statement stmt = conn.createStatement();
2265
2266		try
2267		{
2268		stmt.executeQuery("SELECT ((ID + 1) as N1 FROM sample5");
2269		fail("Should raise a java.sqlSQLException");
2270		}
2271		catch (SQLException e)
2272		{
2273		assertTrue(e.getMessage().startsWith(CsvResources.getString("syntaxError")));
	2356
	2357	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	2358	+ filePath, props);
	2359
	2360	Statement stmt = conn.createStatement())
	2361	{
	2362	try
	2363	{
	2364	stmt.executeQuery("SELECT ((ID + 1) as N1 FROM sample5");
	2365	fail("Should raise a java.sqlSQLException");
	2366	}
	2367	catch (SQLException e)
	2368	{
	2369	assertTrue(e.getMessage().startsWith(CsvResources.getString("syntaxError")));
	2370	}
2274	2371	}
2275	2372	}
2276	2373

2279	2376	{
2280	2377	Properties props = new Properties();
2281	2378	props.put("columnTypes", "Integer,String,String,Date,Time");
2282		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
2283
2284		Statement stmt = conn.createStatement();
2285
2286		ResultSet results = stmt.executeQuery("select lower(job) as ljob, lower('AA') as CAT from sample5");
2287		assertTrue(results.next());
2288		assertEquals("The JOB is wrong", "piloto", results.getString(1));
2289		assertEquals("The CAT is wrong", "aa", results.getString(2));
2290		assertTrue(results.next());
2291		assertEquals("The JOB is wrong", "project manager", results.getString(1));
2292		assertEquals("The CAT is wrong", "aa", results.getString(2));
2293
2294		results = stmt.executeQuery("select ID from sample5 where lower(job) = lower('FINANCE MANAGER')");
2295		assertTrue(results.next());
2296		assertEquals("The ID is wrong", 2, results.getInt(1));
2297		assertFalse(results.next());
	2379
	2380	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
	2381
	2382	Statement stmt = conn.createStatement())
	2383	{
	2384	try (ResultSet results = stmt.executeQuery("select lower(job) as ljob, lower('AA') as CAT from sample5"))
	2385	{
	2386	assertTrue(results.next());
	2387	assertEquals("The JOB is wrong", "piloto", results.getString(1));
	2388	assertEquals("The CAT is wrong", "aa", results.getString(2));
	2389	assertTrue(results.next());
	2390	assertEquals("The JOB is wrong", "project manager", results.getString(1));
	2391	assertEquals("The CAT is wrong", "aa", results.getString(2));
	2392	}
	2393
	2394	try (ResultSet results = stmt.executeQuery("select ID from sample5 where lower(job) = lower('FINANCE MANAGER')"))
	2395	{
	2396	assertTrue(results.next());
	2397	assertEquals("The ID is wrong", 2, results.getInt(1));
	2398	assertFalse(results.next());
	2399	}
	2400	}
2298	2401	}
2299	2402
2300	2403	@Test

2306	2409	props.put("fileExtension", ".txt");
2307	2410	props.put("commentChar", "#");
2308	2411	props.put("columnTypes", "Integer,String");
2309		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
2310
2311		Statement stmt = conn.createStatement();
2312
2313		ResultSet results = stmt.executeQuery("select UPPER(BANK_NAME) as UC, UPPER('Credit' + 'a') as N2, upper(7) as N3 from banks");
2314		assertTrue(results.next());
2315		assertEquals("The BANK_NAME is wrong", "BUNDESBANK (BERLIN)", results.getString(1));
2316		assertEquals("N2 is wrong", "CREDITA", results.getString(2));
2317		assertEquals("N3 is wrong", "7", results.getString(3));
2318
2319		results = stmt.executeQuery("select BLZ from banks where UPPER(BANK_NAME) = 'POSTBANK (BERLIN)'");
2320		assertTrue(results.next());
2321		assertEquals("The BLZ is wrong", 10010010, results.getInt(1));
2322		assertFalse(results.next());
	2412
	2413	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
	2414
	2415	Statement stmt = conn.createStatement())
	2416	{
	2417	try (ResultSet results = stmt.executeQuery("select UPPER(BANK_NAME) as UC, UPPER('Credit' + 'a') as N2, upper(7) as N3 from banks"))
	2418	{
	2419	assertTrue(results.next());
	2420	assertEquals("The BANK_NAME is wrong", "BUNDESBANK (BERLIN)", results.getString(1));
	2421	assertEquals("N2 is wrong", "CREDITA", results.getString(2));
	2422	assertEquals("N3 is wrong", "7", results.getString(3));
	2423	}
	2424
	2425	try (ResultSet results = stmt.executeQuery("select BLZ from banks where UPPER(BANK_NAME) = 'POSTBANK (BERLIN)'"))
	2426	{
	2427	assertTrue(results.next());
	2428	assertEquals("The BLZ is wrong", 10010010, results.getInt(1));
	2429	assertFalse(results.next());
	2430	}
	2431	}
2323	2432	}
2324	2433
2325	2434	@Test

2328	2437	Properties props = new Properties();
2329	2438	props.put("columnTypes", "Integer,String,String,Date,Time");
2330	2439	props.put("charset", "UTF-8");
2331		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
2332
2333		Statement stmt = conn.createStatement();
2334
2335		ResultSet results = stmt.executeQuery("select length(Name) as X, length(Job) as Y, length('') as Z from sample5 where id = 8");
2336		assertTrue(results.next());
2337		assertEquals("The Length is wrong", 27, results.getInt(1));
2338		assertEquals("The Length is wrong", 15, results.getInt(2));
2339		assertEquals("The Length is wrong", 0, results.getInt(3));
2340		assertFalse(results.next());
	2440
	2441	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
	2442
	2443	Statement stmt = conn.createStatement();
	2444
	2445	ResultSet results = stmt.executeQuery("select length(Name) as X, length(Job) as Y, length('') as Z from sample5 where id = 8"))
	2446	{
	2447	assertTrue(results.next());
	2448	assertEquals("The Length is wrong", 27, results.getInt(1));
	2449	assertEquals("The Length is wrong", 15, results.getInt(2));
	2450	assertEquals("The Length is wrong", 0, results.getInt(3));
	2451	assertFalse(results.next());
	2452	}
2341	2453	}
2342	2454
2343	2455	@Test

2347	2459	props.put("columnTypes", "String,Int,Float,String");
2348	2460	props.put("commentChar", "#");
2349	2461	props.put("fileExtension", ".txt");
2350		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
2351
2352		Statement stmt = conn.createStatement();
2353
2354		ResultSet results = stmt.executeQuery("select TRIM(comment), TRIM('\tfoo bar\n') from with_comments");
2355		assertTrue(results.next());
2356		assertEquals("The comment is wrong", "some field", results.getString(1));
2357		assertEquals("The trimmed value is wrong", "foo bar", results.getString(2));
2358		assertTrue(results.next());
2359		assertEquals("The comment is wrong", "other parameter", results.getString(1));
2360		assertTrue(results.next());
2361		assertEquals("The comment is wrong", "still a field", results.getString(1));
2362		assertFalse(results.next());
2363
2364		results = stmt.executeQuery("select TRIM(name, '#'), TRIM(name, '#h'), TRIM('00000', '0') from with_comments");
2365		assertTrue(results.next());
2366		assertEquals("The trimmed value is wrong", "alpha", results.getString(1));
2367		assertEquals("The trimmed value is wrong", "alpha", results.getString(2));
2368		assertEquals("The trimmed value is wrong", "", results.getString(3));
2369		assertTrue(results.next());
2370		assertEquals("The trimmed value is wrong", "beta", results.getString(1));
2371		assertEquals("The trimmed value is wrong", "beta", results.getString(2));
2372		assertTrue(results.next());
2373		assertEquals("The trimmed value is wrong", "hash", results.getString(1));
2374		assertEquals("The trimmed value is wrong", "as", results.getString(2));
2375		assertFalse(results.next());
	2462
	2463	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
	2464
	2465	Statement stmt = conn.createStatement())
	2466	{
	2467	try (ResultSet results = stmt.executeQuery("select TRIM(comment), TRIM('\tfoo bar\n') from with_comments"))
	2468	{
	2469	assertTrue(results.next());
	2470	assertEquals("The comment is wrong", "some field", results.getString(1));
	2471	assertEquals("The trimmed value is wrong", "foo bar", results.getString(2));
	2472	assertTrue(results.next());
	2473	assertEquals("The comment is wrong", "other parameter", results.getString(1));
	2474	assertTrue(results.next());
	2475	assertEquals("The comment is wrong", "still a field", results.getString(1));
	2476	assertFalse(results.next());
	2477	}
	2478
	2479	try (ResultSet results = stmt.executeQuery("select TRIM(name, '#'), TRIM(name, '#h'), TRIM('00000', '0') from with_comments"))
	2480	{
	2481	assertTrue(results.next());
	2482	assertEquals("The trimmed value is wrong", "alpha", results.getString(1));
	2483	assertEquals("The trimmed value is wrong", "alpha", results.getString(2));
	2484	assertEquals("The trimmed value is wrong", "", results.getString(3));
	2485	assertTrue(results.next());
	2486	assertEquals("The trimmed value is wrong", "beta", results.getString(1));
	2487	assertEquals("The trimmed value is wrong", "beta", results.getString(2));
	2488	assertTrue(results.next());
	2489	assertEquals("The trimmed value is wrong", "hash", results.getString(1));
	2490	assertEquals("The trimmed value is wrong", "as", results.getString(2));
	2491	assertFalse(results.next());
	2492	}
	2493	}
2376	2494	}
2377	2495
2378	2496	@Test
2379	2497	public void testLTrimFunction() throws SQLException
2380	2498	{
2381		Properties props = new Properties();
	2499	Properties props = new Properties();
2382	2500	props.put("headerline", "TRANS_DATE,FROM_ACCT,FROM_BLZ,TO_ACCT,TO_BLZ,AMOUNT");
2383	2501	props.put("suppressHeaders", "true");
2384	2502	props.put("fileExtension", ".txt");
2385	2503	props.put("commentChar", "#");
2386		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
2387		+ filePath, props);
2388		Statement stmt = conn.createStatement();
2389		ResultSet results = stmt.executeQuery("SELECT LTRIM(TO_ACCT,'0'), LTRIM('0000','0'), LTRIM('','0'), LTRIM(' X ') FROM transactions");
2390		assertTrue(results.next());
2391		assertEquals("The trimmed value is wrong", "27853256", results.getString(1));
2392		assertEquals("The trimmed value is wrong", "", results.getString(2));
2393		assertEquals("The trimmed value is wrong", "", results.getString(3));
2394		assertEquals("The trimmed value is wrong", "X ", results.getString(4));
2395		assertTrue(results.next());
2396		assertEquals("The trimmed value is wrong", "27234813", results.getString(1));
2397		assertTrue(results.next());
2398		assertEquals("The trimmed value is wrong", "81824588", results.getString(1));
	2504
	2505	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	2506	+ filePath, props);
	2507	Statement stmt = conn.createStatement();
	2508	ResultSet results = stmt.executeQuery("SELECT LTRIM(TO_ACCT,'0'), LTRIM('0000','0'), LTRIM('','0'), LTRIM(' X ') FROM transactions"))
	2509	{
	2510	assertTrue(results.next());
	2511	assertEquals("The trimmed value is wrong", "27853256", results.getString(1));
	2512	assertEquals("The trimmed value is wrong", "", results.getString(2));
	2513	assertEquals("The trimmed value is wrong", "", results.getString(3));
	2514	assertEquals("The trimmed value is wrong", "X ", results.getString(4));
	2515	assertTrue(results.next());
	2516	assertEquals("The trimmed value is wrong", "27234813", results.getString(1));
	2517	assertTrue(results.next());
	2518	assertEquals("The trimmed value is wrong", "81824588", results.getString(1));
	2519	}
2399	2520	}
2400	2521
2401	2522	@Test
2402	2523	public void testRTrimFunction() throws SQLException
2403	2524	{
2404		Properties props = new Properties();
	2525	Properties props = new Properties();
2405	2526	props.put("headerline", "BLZ,BANK_NAME");
2406	2527	props.put("suppressHeaders", "true");
2407	2528	props.put("fileExtension", ".txt");
2408	2529	props.put("commentChar", "#");
2409		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
2410		+ filePath, props);
2411		Statement stmt = conn.createStatement();
2412		ResultSet results = stmt.executeQuery("SELECT RTRIM(BLZ,'0'), RTRIM(' ZZ ') FROM banks");
2413		assertTrue(results.next());
2414		assertEquals("The trimmed value is wrong", "1", results.getString(1));
2415		assertEquals("The trimmed value is wrong", " ZZ", results.getString(2));
2416		assertTrue(results.next());
2417		assertEquals("The trimmed value is wrong", "1001001", results.getString(1));
2418		assertTrue(results.next());
2419		assertEquals("The trimmed value is wrong", "10010111", results.getString(1));
	2530
	2531	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	2532	+ filePath, props);
	2533	Statement stmt = conn.createStatement();
	2534	ResultSet results = stmt.executeQuery("SELECT RTRIM(BLZ,'0'), RTRIM(' ZZ ') FROM banks"))
	2535	{
	2536	assertTrue(results.next());
	2537	assertEquals("The trimmed value is wrong", "1", results.getString(1));
	2538	assertEquals("The trimmed value is wrong", " ZZ", results.getString(2));
	2539	assertTrue(results.next());
	2540	assertEquals("The trimmed value is wrong", "1001001", results.getString(1));
	2541	assertTrue(results.next());
	2542	assertEquals("The trimmed value is wrong", "10010111", results.getString(1));
	2543	}
2420	2544	}
2421	2545
2422	2546	@Test
2423	2547	public void testSubstringFunction() throws SQLException
2424	2548	{
2425		Properties props = new Properties();
2426		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
2427		+ filePath, props);
2428		Statement stmt = conn.createStatement();
2429		ResultSet results = stmt.executeQuery("SELECT substring(name, 2), substring(name, 3, 4), substring(name, 200) FROM sample4");
2430		assertTrue(results.next());
2431		assertEquals("The substring is wrong", "uan Pablo Morales", results.getString(1));
2432		assertEquals("The substring is wrong", "an P", results.getString(2));
2433		assertEquals("The substring is wrong", "", results.getString(3));
	2549	Properties props = new Properties();
	2550
	2551	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	2552	+ filePath, props);
	2553	Statement stmt = conn.createStatement();
	2554	ResultSet results = stmt.executeQuery("SELECT substring(name, 2), substring(name, 3, 4), substring(name, 200) FROM sample4"))
	2555	{
	2556	assertTrue(results.next());
	2557	assertEquals("The substring is wrong", "uan Pablo Morales", results.getString(1));
	2558	assertEquals("The substring is wrong", "an P", results.getString(2));
	2559	assertEquals("The substring is wrong", "", results.getString(3));
	2560	}
2434	2561	}
2435	2562
2436	2563	/**

2446	2573	{
2447	2574	Properties props = new Properties();
2448	2575	props.put("columnTypes", "Byte,Short,Integer,Long,Float,Double,BigDecimal");
2449		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
2450
2451		Statement stmt = conn.createStatement();
2452
2453		ResultSet results = stmt.executeQuery("select ABS(C2) as R1, ABS(C5) as R2, ABS('-123456') as R3 from numeric");
2454		assertTrue(results.next());
2455		assertEquals("R1 is wrong", 1010, results.getInt(1));
2456		assertTrue("R2 is wrong", fuzzyEquals(results.getDouble(2), 3.14));
2457		assertTrue("R3 is wrong", fuzzyEquals(results.getDouble(3), 123456));
2458		assertTrue(results.next());
2459		assertEquals("R1 is wrong", 15, results.getInt(1));
2460		assertTrue("R2 is wrong", fuzzyEquals(results.getDouble(2), 0.0));
2461		assertFalse(results.next());
	2576
	2577	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
	2578
	2579	Statement stmt = conn.createStatement();
	2580
	2581	ResultSet results = stmt.executeQuery("select ABS(C2) as R1, ABS(C5) as R2, ABS('-123456') as R3 from numeric"))
	2582	{
	2583	assertTrue(results.next());
	2584	assertEquals("R1 is wrong", 1010, results.getInt(1));
	2585	assertTrue("R2 is wrong", fuzzyEquals(results.getDouble(2), 3.14));
	2586	assertTrue("R3 is wrong", fuzzyEquals(results.getDouble(3), 123456));
	2587	assertTrue(results.next());
	2588	assertEquals("R1 is wrong", 15, results.getInt(1));
	2589	assertTrue("R2 is wrong", fuzzyEquals(results.getDouble(2), 0.0));
	2590	assertFalse(results.next());
	2591	}
2462	2592	}
2463	2593
2464	2594	@Test

2466	2596	{
2467	2597	Properties props = new Properties();
2468	2598	props.put("columnTypes", "Byte,Short,Integer,Long,Float,Double,BigDecimal");
2469		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
2470
2471		Statement stmt = conn.createStatement();
2472
2473		ResultSet results = stmt.executeQuery("select ROUND(11.77) as R1, ROUND('11.77') as R2, ROUND(C2) as R3, round(C3/7.0) as R4 from numeric where ROUND(C5) = 3");
2474		assertTrue(results.next());
2475		assertEquals("R1 is wrong", 12, results.getInt(1));
2476		assertEquals("R2 is wrong", 12, results.getInt(2));
2477		assertEquals("R3 is wrong", -1010, results.getInt(3));
2478		assertEquals("R4 is wrong", 42871, results.getInt(4));
2479		assertFalse(results.next());
	2599
	2600	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
	2601
	2602	Statement stmt = conn.createStatement();
	2603
	2604	ResultSet results = stmt.executeQuery("select ROUND(11.77) as R1, ROUND('11.77') as R2, ROUND(C2) as R3, round(C3/7.0) as R4 from numeric where ROUND(C5) = 3"))
	2605	{
	2606	assertTrue(results.next());
	2607	assertEquals("R1 is wrong", 12, results.getInt(1));
	2608	assertEquals("R2 is wrong", 12, results.getInt(2));
	2609	assertEquals("R3 is wrong", -1010, results.getInt(3));
	2610	assertEquals("R4 is wrong", 42871, results.getInt(4));
	2611	assertFalse(results.next());
	2612	}
2480	2613	}
2481	2614
2482	2615	@Test

2485	2618	Properties props = new Properties();
2486	2619	props.put("columnTypes", "Integer,String,Date,Time");
2487	2620	props.put("timeZoneName", TimeZone.getDefault().getID());
2488		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
2489
2490		Statement stmt = conn.createStatement();
2491
2492		ResultSet results = stmt.executeQuery("select dayofmonth(d) as dom, " +
2493		"dayofmonth('2013-10-13') as today from sample8");
2494		assertTrue(results.next());
2495		assertEquals("dom is wrong", 2, results.getInt(1));
2496		assertEquals("today is wrong", 13, results.getInt(2));
2497		assertTrue(results.next());
2498		assertEquals("dom is wrong", 2, results.getInt(1));
2499		assertTrue(results.next());
2500		assertEquals("dom is wrong", 28, results.getInt(1));
	2621
	2622	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
	2623
	2624	Statement stmt = conn.createStatement();
	2625
	2626	ResultSet results = stmt.executeQuery("select dayofmonth(d) as dom, " +
	2627	"dayofmonth('2013-10-13') as today from sample8"))
	2628	{
	2629	assertTrue(results.next());
	2630	assertEquals("dom is wrong", 2, results.getInt(1));
	2631	assertEquals("today is wrong", 13, results.getInt(2));
	2632	assertTrue(results.next());
	2633	assertEquals("dom is wrong", 2, results.getInt(1));
	2634	assertTrue(results.next());
	2635	assertEquals("dom is wrong", 28, results.getInt(1));
	2636	}
2501	2637	}
2502	2638
2503	2639	@Test

2505	2641	{
2506	2642	Properties props = new Properties();
2507	2643	props.put("columnTypes", "Integer,String,Date,Time");
2508		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
2509
2510		Statement stmt = conn.createStatement();
2511
2512		ResultSet results = stmt.executeQuery("select month(d) as month, " +
2513		"month('2013-10-13') as today from sample8");
2514		assertTrue(results.next());
2515		assertEquals("month is wrong", 1, results.getInt(1));
2516		assertEquals("today is wrong", 10, results.getInt(2));
2517		assertTrue(results.next());
2518		assertEquals("dom is wrong", 2, results.getInt(1));
2519		assertTrue(results.next());
2520		assertEquals("dom is wrong", 3, results.getInt(1));
	2644
	2645	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
	2646
	2647	Statement stmt = conn.createStatement();
	2648
	2649	ResultSet results = stmt.executeQuery("select month(d) as month, " +
	2650	"month('2013-10-13') as today from sample8"))
	2651	{
	2652	assertTrue(results.next());
	2653	assertEquals("month is wrong", 1, results.getInt(1));
	2654	assertEquals("today is wrong", 10, results.getInt(2));
	2655	assertTrue(results.next());
	2656	assertEquals("dom is wrong", 2, results.getInt(1));
	2657	assertTrue(results.next());
	2658	assertEquals("dom is wrong", 3, results.getInt(1));
	2659	}
2521	2660	}
2522	2661
2523	2662	@Test

2526	2665	Properties props = new Properties();
2527	2666	props.put("columnTypes", "Integer,String,Date,Time");
2528	2667	props.put("timeZoneName", TimeZone.getDefault().getID());
2529		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
2530
2531		Statement stmt = conn.createStatement();
2532
2533		ResultSet results = stmt.executeQuery("select year(d) as year, " +
2534		"year('2013-10-13') as today from sample8");
2535		assertTrue(results.next());
2536		assertEquals("month is wrong", 2010, results.getInt(1));
2537		assertEquals("today is wrong", 2013, results.getInt(2));
2538		assertTrue(results.next());
2539		assertEquals("dom is wrong", 2010, results.getInt(1));
2540		assertTrue(results.next());
2541		assertEquals("dom is wrong", 2010, results.getInt(1));
2542		assertTrue(results.next());
2543		assertEquals("dom is wrong", 2010, results.getInt(1));
2544		assertTrue(results.next());
2545		assertEquals("dom is wrong", 2009, results.getInt(1));
	2668
	2669	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
	2670
	2671	Statement stmt = conn.createStatement();
	2672
	2673	ResultSet results = stmt.executeQuery("select year(d) as year, " +
	2674	"year('2013-10-13') as today from sample8"))
	2675	{
	2676	assertTrue(results.next());
	2677	assertEquals("month is wrong", 2010, results.getInt(1));
	2678	assertEquals("today is wrong", 2013, results.getInt(2));
	2679	assertTrue(results.next());
	2680	assertEquals("dom is wrong", 2010, results.getInt(1));
	2681	assertTrue(results.next());
	2682	assertEquals("dom is wrong", 2010, results.getInt(1));
	2683	assertTrue(results.next());
	2684	assertEquals("dom is wrong", 2010, results.getInt(1));
	2685	assertTrue(results.next());
	2686	assertEquals("dom is wrong", 2009, results.getInt(1));
	2687	}
2546	2688	}
2547	2689
2548	2690	@Test

2550	2692	{
2551	2693	Properties props = new Properties();
2552	2694	props.put("columnTypes", "Integer,String,Date,Time");
2553		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
2554
2555		Statement stmt = conn.createStatement();
2556
2557		ResultSet results = stmt.executeQuery("select hourofday(t) as hour, " +
2558		"hourofday('23:41:17') as h from sample8");
2559		assertTrue(results.next());
2560		assertEquals("hour is wrong", 1, results.getInt(1));
2561		assertEquals("h is wrong", 23, results.getInt(2));
2562		assertTrue(results.next());
2563		assertEquals("hour is wrong", 1, results.getInt(1));
2564		assertTrue(results.next());
2565		assertEquals("hour is wrong", 1, results.getInt(1));
2566		assertTrue(results.next());
2567		assertEquals("hour is wrong", 5, results.getInt(1));
	2695
	2696	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
	2697
	2698	Statement stmt = conn.createStatement();
	2699
	2700	ResultSet results = stmt.executeQuery("select hourofday(t) as hour, " +
	2701	"hourofday('23:41:17') as h from sample8"))
	2702	{
	2703	assertTrue(results.next());
	2704	assertEquals("hour is wrong", 1, results.getInt(1));
	2705	assertEquals("h is wrong", 23, results.getInt(2));
	2706	assertTrue(results.next());
	2707	assertEquals("hour is wrong", 1, results.getInt(1));
	2708	assertTrue(results.next());
	2709	assertEquals("hour is wrong", 1, results.getInt(1));
	2710	assertTrue(results.next());
	2711	assertEquals("hour is wrong", 5, results.getInt(1));
	2712	}
2568	2713	}
2569	2714
2570	2715	@Test

2572	2717	{
2573	2718	Properties props = new Properties();
2574	2719	props.put("columnTypes", "Integer,String,Date,Time");
2575		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
2576
2577		Statement stmt = conn.createStatement();
2578
2579		ResultSet results = stmt.executeQuery("select minute(t) as minute, " +
2580		"minute('23:41:17') as m from sample8");
2581		assertTrue(results.next());
2582		assertEquals("minute is wrong", 30, results.getInt(1));
2583		assertEquals("m is wrong", 41, results.getInt(2));
	2720
	2721	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
	2722
	2723	Statement stmt = conn.createStatement();
	2724
	2725	ResultSet results = stmt.executeQuery("select minute(t) as minute, " +
	2726	"minute('23:41:17') as m from sample8"))
	2727	{
	2728	assertTrue(results.next());
	2729	assertEquals("minute is wrong", 30, results.getInt(1));
	2730	assertEquals("m is wrong", 41, results.getInt(2));
	2731	}
2584	2732	}
2585	2733
2586	2734	@Test

2589	2737	Properties props = new Properties();
2590	2738	props.put("columnTypes", "Int,String,String,Timestamp");
2591	2739	props.put("timeZoneName", TimeZone.getDefault().getID());
2592		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
2593
2594		Statement stmt = conn.createStatement();
2595
2596		ResultSet results = stmt.executeQuery("select dayofmonth(Start), month(Start), year(Start), " +
2597		"hourofday(Start), minute(Start), second(Start) from sample5");
2598		assertTrue(results.next());
2599		assertEquals("dayofmonth is wrong", 2, results.getInt(1));
2600		assertEquals("month is wrong", 4, results.getInt(2));
2601		assertEquals("year is wrong", 2001, results.getInt(3));
2602		assertEquals("hourofday is wrong", 12, results.getInt(4));
2603		assertEquals("minute is wrong", 30, results.getInt(5));
2604		assertEquals("second is wrong", 0, results.getInt(6));
2605
2606		String timestamp = "2013-10-13 14:33:55";
2607		results = stmt.executeQuery("select dayofmonth('" + timestamp + "')," +
2608		"month('" + timestamp + "'), year('" + timestamp + "'), " +
2609		"hourofday('" + timestamp + "'), minute('" + timestamp + "'), " +
2610		"second('" + timestamp + "') from sample5");
2611		assertTrue(results.next());
2612		assertEquals("dayofmonth is wrong", 13, results.getInt(1));
2613		assertEquals("month is wrong", 10, results.getInt(2));
2614		assertEquals("year is wrong", 2013, results.getInt(3));
2615		assertEquals("hourofday is wrong", 14, results.getInt(4));
2616		assertEquals("minute is wrong", 33, results.getInt(5));
2617		assertEquals("second is wrong", 55, results.getInt(6));
	2740
	2741	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
	2742
	2743	Statement stmt = conn.createStatement())
	2744	{
	2745	try (ResultSet results = stmt.executeQuery("select dayofmonth(Start), month(Start), year(Start), " +
	2746	"hourofday(Start), minute(Start), second(Start) from sample5"))
	2747	{
	2748	assertTrue(results.next());
	2749	assertEquals("dayofmonth is wrong", 2, results.getInt(1));
	2750	assertEquals("month is wrong", 4, results.getInt(2));
	2751	assertEquals("year is wrong", 2001, results.getInt(3));
	2752	assertEquals("hourofday is wrong", 12, results.getInt(4));
	2753	assertEquals("minute is wrong", 30, results.getInt(5));
	2754	assertEquals("second is wrong", 0, results.getInt(6));
	2755	}
	2756
	2757	String timestamp = "2013-10-13 14:33:55";
	2758	try (ResultSet results = stmt.executeQuery("select dayofmonth('" + timestamp + "')," +
	2759	"month('" + timestamp + "'), year('" + timestamp + "'), " +
	2760	"hourofday('" + timestamp + "'), minute('" + timestamp + "'), " +
	2761	"second('" + timestamp + "') from sample5"))
	2762	{
	2763	assertTrue(results.next());
	2764	assertEquals("dayofmonth is wrong", 13, results.getInt(1));
	2765	assertEquals("month is wrong", 10, results.getInt(2));
	2766	assertEquals("year is wrong", 2013, results.getInt(3));
	2767	assertEquals("hourofday is wrong", 14, results.getInt(4));
	2768	assertEquals("minute is wrong", 33, results.getInt(5));
	2769	assertEquals("second is wrong", 55, results.getInt(6));
	2770	}
	2771	}
2618	2772	}
2619	2773
2620	2774	@Test

2623	2777	Properties props = new Properties();
2624	2778	props.put("trimHeaders", "true");
2625	2779	props.put("trimValues", "true");
2626		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
2627
2628		Statement stmt = conn.createStatement();
2629
2630		ResultSet results = stmt.executeQuery("select nullif(key, ' - ') as k2 from foodstuffs");
2631		assertTrue(results.next());
2632		assertEquals("K2 is wrong", "orange", results.getString(1));
2633		assertTrue(results.next());
2634		assertEquals("K2 is wrong", "apple", results.getString(1));
2635		assertTrue(results.next());
2636		assertTrue(results.next());
2637		assertTrue(results.next());
2638		assertTrue(results.next());
2639		assertEquals("K2 is wrong", null, results.getString(1));
2640		assertTrue(results.wasNull());
2641		assertFalse(results.next());
	2780
	2781	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
	2782
	2783	Statement stmt = conn.createStatement();
	2784
	2785	ResultSet results = stmt.executeQuery("select nullif(key, ' - ') as k2 from foodstuffs"))
	2786	{
	2787	assertTrue(results.next());
	2788	assertEquals("K2 is wrong", "orange", results.getString(1));
	2789	assertTrue(results.next());
	2790	assertEquals("K2 is wrong", "apple", results.getString(1));
	2791	assertTrue(results.next());
	2792	assertTrue(results.next());
	2793	assertTrue(results.next());
	2794	assertTrue(results.next());
	2795	assertEquals("K2 is wrong", null, results.getString(1));
	2796	assertTrue(results.wasNull());
	2797	assertFalse(results.next());
	2798	}
2642	2799	}
2643	2800
2644	2801	@Test

2646	2803	{
2647	2804	Properties props = new Properties();
2648	2805	props.put("columnTypes", "Integer,String,Date,Time");
2649		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
2650
2651		Statement stmt = conn.createStatement();
2652
2653		ResultSet results = stmt.executeQuery("SELECT COALESCE(ID, 999) FROM bad_values");
2654		assertTrue(results.next());
2655		assertEquals("ID is wrong", 999, results.getInt(1));
2656		assertTrue(results.next());
2657		assertEquals("ID is wrong", 999, results.getInt(1));
2658		assertTrue(results.next());
2659		assertEquals("ID is wrong", 3, results.getInt(1));
2660		assertFalse(results.next());
	2806
	2807	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
	2808
	2809	Statement stmt = conn.createStatement();
	2810
	2811	ResultSet results = stmt.executeQuery("SELECT COALESCE(ID, 999) FROM bad_values"))
	2812	{
	2813	assertTrue(results.next());
	2814	assertEquals("ID is wrong", 999, results.getInt(1));
	2815	assertTrue(results.next());
	2816	assertEquals("ID is wrong", 999, results.getInt(1));
	2817	assertTrue(results.next());
	2818	assertEquals("ID is wrong", 3, results.getInt(1));
	2819	assertFalse(results.next());
	2820	}
2661	2821	}
2662	2822
2663	2823	@Test

2667	2827	props.put("columnTypes", "String,Int,Float,String");
2668	2828	props.put("commentChar", "#");
2669	2829	props.put("fileExtension", ".txt");
2670		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
2671		+ filePath, props);
2672		Statement stmt = conn.createStatement();
2673		ResultSet results = stmt.executeQuery("SELECT * FROM with_comments");
2674
2675		ResultSetMetaData metadata = results.getMetaData();
2676		assertEquals("name", metadata.getColumnName(1));
2677		assertEquals("id", metadata.getColumnName(2));
2678		assertEquals("value", metadata.getColumnName(3));
2679		assertEquals("comment", metadata.getColumnName(4));
2680
2681		assertTrue(results.next());
2682		assertEquals(new Integer(1), results.getObject(2));
2683		assertTrue(results.next());
2684		assertEquals(new Integer(2), results.getObject(2));
2685		assertTrue(results.next());
2686		assertEquals(new Integer(3), results.getObject(2));
2687		assertFalse(results.next());
	2830
	2831	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	2832	+ filePath, props);
	2833	Statement stmt = conn.createStatement();
	2834	ResultSet results = stmt.executeQuery("SELECT * FROM with_comments"))
	2835	{
	2836	ResultSetMetaData metadata = results.getMetaData();
	2837	assertEquals("name", metadata.getColumnName(1));
	2838	assertEquals("id", metadata.getColumnName(2));
	2839	assertEquals("value", metadata.getColumnName(3));
	2840	assertEquals("comment", metadata.getColumnName(4));
	2841
	2842	assertTrue(results.next());
	2843	assertEquals(Integer.valueOf(1), results.getObject(2));
	2844	assertTrue(results.next());
	2845	assertEquals(Integer.valueOf(2), results.getObject(2));
	2846	assertTrue(results.next());
	2847	assertEquals(Integer.valueOf(3), results.getObject(2));
	2848	assertFalse(results.next());
	2849	}
2688	2850	}
2689	2851
2690	2852	@Test

2692	2854	{
2693	2855	Properties props = new Properties();
2694	2856	props.put("commentChar", "");
2695		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
2696		+ filePath, props);
2697		Statement stmt = conn.createStatement();
2698		ResultSet results = stmt.executeQuery("SELECT * FROM sample5");
2699
2700		ResultSetMetaData metadata = results.getMetaData();
2701		assertEquals("ID", metadata.getColumnName(1));
2702		assertEquals("Name", metadata.getColumnName(2));
2703		assertEquals("Job", metadata.getColumnName(3));
2704		assertEquals("Start", metadata.getColumnName(4));
2705
2706		assertTrue(results.next());
2707		assertEquals("41", results.getObject(1));
2708		assertTrue(results.next());
2709		assertEquals("01", results.getObject(1));
2710		assertTrue(results.next());
2711		assertEquals("02", results.getObject(1));
2712		assertTrue(results.next());
2713		assertEquals("03", results.getObject(1));
2714		assertTrue(results.next());
2715		assertEquals("04", results.getObject(1));
2716		assertTrue(results.next());
2717		assertEquals("05", results.getObject(1));
2718		assertTrue(results.next());
2719		assertEquals("06", results.getObject(1));
2720		assertTrue(results.next());
2721		assertEquals("07", results.getObject(1));
2722		assertTrue(results.next());
2723		assertEquals("08", results.getObject(1));
2724		assertTrue(results.next());
2725		assertEquals("09", results.getObject(1));
2726		assertFalse(results.next());
	2857
	2858	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	2859	+ filePath, props);
	2860	Statement stmt = conn.createStatement();
	2861	ResultSet results = stmt.executeQuery("SELECT * FROM sample5"))
	2862	{
	2863	ResultSetMetaData metadata = results.getMetaData();
	2864	assertEquals("ID", metadata.getColumnName(1));
	2865	assertEquals("Name", metadata.getColumnName(2));
	2866	assertEquals("Job", metadata.getColumnName(3));
	2867	assertEquals("Start", metadata.getColumnName(4));
	2868
	2869	assertTrue(results.next());
	2870	assertEquals("41", results.getObject(1));
	2871	assertTrue(results.next());
	2872	assertEquals("01", results.getObject(1));
	2873	assertTrue(results.next());
	2874	assertEquals("02", results.getObject(1));
	2875	assertTrue(results.next());
	2876	assertEquals("03", results.getObject(1));
	2877	assertTrue(results.next());
	2878	assertEquals("04", results.getObject(1));
	2879	assertTrue(results.next());
	2880	assertEquals("05", results.getObject(1));
	2881	assertTrue(results.next());
	2882	assertEquals("06", results.getObject(1));
	2883	assertTrue(results.next());
	2884	assertEquals("07", results.getObject(1));
	2885	assertTrue(results.next());
	2886	assertEquals("08", results.getObject(1));
	2887	assertTrue(results.next());
	2888	assertEquals("09", results.getObject(1));
	2889	assertFalse(results.next());
	2890	}
2727	2891	}
2728	2892
2729	2893	@Test

2735	2899	/*
2736	2900	* Check that the 3 byte Byte Order Mark at start of file is skipped.
2737	2901	*/
2738		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
2739		+ filePath, props);
2740		Statement stmt = conn.createStatement();
2741		ResultSet results = stmt.executeQuery("SELECT * FROM utf8_bom");
2742
2743		assertTrue(results.next());
2744		ResultSetMetaData metadata = results.getMetaData();
2745		assertEquals("name of column 1 is incorrect", "foo", metadata.getColumnName(1));
2746		assertEquals("name of column 2 is incorrect", "bar", metadata.getColumnName(2));
2747		assertEquals("Incorrect value 1", "1", results.getString(1));
2748		assertEquals("Incorrect value 2", "3", results.getString(2));
	2902	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	2903	+ filePath, props);
	2904	Statement stmt = conn.createStatement();
	2905	ResultSet results = stmt.executeQuery("SELECT * FROM utf8_bom"))
	2906	{
	2907	assertTrue(results.next());
	2908	ResultSetMetaData metadata = results.getMetaData();
	2909	assertEquals("name of column 1 is incorrect", "foo", metadata.getColumnName(1));
	2910	assertEquals("name of column 2 is incorrect", "bar", metadata.getColumnName(2));
	2911	assertEquals("Incorrect value 1", "1", results.getString(1));
	2912	assertEquals("Incorrect value 2", "3", results.getString(2));
	2913	}
2749	2914	}
2750	2915
2751	2916	@Test

2755	2920	props.put("columnTypes", "String,Int,Float,String");
2756	2921	props.put("skipLeadingLines", "3");
2757	2922	props.put("fileExtension", ".txt");
2758		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
2759		+ filePath, props);
2760		Statement stmt = conn.createStatement();
2761		ResultSet results = stmt.executeQuery("SELECT * FROM with_comments");
2762
2763		ResultSetMetaData metadata = results.getMetaData();
2764		assertEquals("name", metadata.getColumnName(1));
2765		assertEquals("id", metadata.getColumnName(2));
2766		assertEquals("value", metadata.getColumnName(3));
2767		assertEquals("comment", metadata.getColumnName(4));
2768
2769		assertTrue(results.next());
2770		assertEquals(new Integer(1), results.getObject(2));
2771		assertTrue(results.next());
2772		assertEquals(new Integer(2), results.getObject(2));
2773		assertTrue(results.next());
2774		assertEquals(new Integer(3), results.getObject(2));
2775		assertFalse(results.next());
	2923
	2924	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	2925	+ filePath, props);
	2926	Statement stmt = conn.createStatement();
	2927	ResultSet results = stmt.executeQuery("SELECT * FROM with_comments"))
	2928	{
	2929	ResultSetMetaData metadata = results.getMetaData();
	2930	assertEquals("name", metadata.getColumnName(1));
	2931	assertEquals("id", metadata.getColumnName(2));
	2932	assertEquals("value", metadata.getColumnName(3));
	2933	assertEquals("comment", metadata.getColumnName(4));
	2934
	2935	assertTrue(results.next());
	2936	assertEquals(Integer.valueOf(1), results.getObject(2));
	2937	assertTrue(results.next());
	2938	assertEquals(Integer.valueOf(2), results.getObject(2));
	2939	assertTrue(results.next());
	2940	assertEquals(Integer.valueOf(3), results.getObject(2));
	2941	assertFalse(results.next());
	2942	}
2776	2943	}
2777	2944
2778	2945	@Test

2784	2951	props.put("separator", ";");
2785	2952	props.put("fileExtension", ".txt");
2786	2953	props.put("suppressHeaders", "true");
2787		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
2788		+ filePath, props);
2789		Statement stmt = conn.createStatement();
2790		ResultSet results = stmt
2791		.executeQuery("SELECT * FROM with_leading_trash");
2792
2793		assertTrue(results.next());
2794		assertEquals("12:20", results.getString(2));
2795		assertTrue(results.next());
2796		assertEquals("12:30", results.getString(2));
2797		assertTrue(results.next());
2798		assertEquals("12:40", results.getObject(2));
2799		assertFalse(results.next());
	2954
	2955	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	2956	+ filePath, props);
	2957	Statement stmt = conn.createStatement();
	2958	ResultSet results = stmt
	2959	.executeQuery("SELECT * FROM with_leading_trash"))
	2960	{
	2961	assertTrue(results.next());
	2962	assertEquals("12:20", results.getString(2));
	2963	assertTrue(results.next());
	2964	assertEquals("12:30", results.getString(2));
	2965	assertTrue(results.next());
	2966	assertEquals("12:40", results.getObject(2));
	2967	assertFalse(results.next());
	2968	}
2800	2969	}
2801	2970
2802	2971	@Test

2808	2977	props.put("separator", ";");
2809	2978	props.put("fileExtension", ".txt");
2810	2979	props.put("suppressHeaders", "true");
2811		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
2812		+ filePath, props);
2813		Statement stmt = conn.createStatement();
2814		ResultSet results = stmt
2815		.executeQuery("SELECT * FROM with_leading_trash");
2816
2817		assertTrue(results.next());
2818		assertEquals("12:20", results.getString(2));
2819		assertTrue(results.next());
2820		assertEquals("12:30", results.getString(2));
2821		assertTrue(results.next());
2822		assertEquals("12:40", results.getObject(2));
2823		assertFalse(results.next());
	2980
	2981	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	2982	+ filePath, props);
	2983	Statement stmt = conn.createStatement();
	2984	ResultSet results = stmt
	2985	.executeQuery("SELECT * FROM with_leading_trash"))
	2986	{
	2987	assertTrue(results.next());
	2988	assertEquals("12:20", results.getString(2));
	2989	assertTrue(results.next());
	2990	assertEquals("12:30", results.getString(2));
	2991	assertTrue(results.next());
	2992	assertEquals("12:40", results.getObject(2));
	2993	assertFalse(results.next());
	2994	}
2824	2995	}
2825	2996
2826	2997	@Test

2830	3001	props.put("ignoreNonParseableLines", "True");
2831	3002	props.put("separator", ";");
2832	3003	props.put("fileExtension", ".txt");
2833		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
2834		+ filePath, props);
2835		Statement stmt = conn.createStatement();
2836		ResultSet results = stmt
2837		.executeQuery("SELECT * FROM with_leading_trash");
2838
2839		ResultSetMetaData metadata = results.getMetaData();
2840		assertEquals("12:20", metadata.getColumnName(2));
2841
2842		assertTrue(results.next());
2843		assertEquals("12:30", results.getString(2));
2844		assertTrue(results.next());
2845		assertEquals("12:40", results.getObject(2));
2846		assertFalse(results.next());
	3004
	3005	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	3006	+ filePath, props);
	3007	Statement stmt = conn.createStatement();
	3008	ResultSet results = stmt
	3009	.executeQuery("SELECT * FROM with_leading_trash"))
	3010	{
	3011	ResultSetMetaData metadata = results.getMetaData();
	3012	assertEquals("12:20", metadata.getColumnName(2));
	3013
	3014	assertTrue(results.next());
	3015	assertEquals("12:30", results.getString(2));
	3016	assertTrue(results.next());
	3017	assertEquals("12:40", results.getObject(2));
	3018	assertFalse(results.next());
	3019	}
2847	3020	}
2848	3021
2849	3022	@Test

2854	3027	props.put("suppressHeaders", "true");
2855	3028	props.put("ignoreNonParseableLines", "True");
2856	3029	props.put("fileExtension", ".txt");
2857		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
2858		+ filePath, props);
2859		Statement stmt = conn.createStatement();
2860		ResultSet results = stmt
2861		.executeQuery("SELECT * FROM embassies");
2862
2863		assertTrue(results.next());
2864		assertEquals("Germany", results.getString(1));
2865		assertTrue(results.next());
2866		assertEquals("United Kingdom", results.getString(1));
2867		assertFalse(results.next());
	3030
	3031	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	3032	+ filePath, props);
	3033	Statement stmt = conn.createStatement();
	3034	ResultSet results = stmt
	3035	.executeQuery("SELECT * FROM embassies"))
	3036	{
	3037	assertTrue(results.next());
	3038	assertEquals("Germany", results.getString(1));
	3039	assertTrue(results.next());
	3040	assertEquals("United Kingdom", results.getString(1));
	3041	assertFalse(results.next());
	3042	}
2868	3043	}
2869	3044
2870	3045	@Test

2874	3049	props.put("ignoreNonParseableLines", "True");
2875	3050	props.put("separator", ";");
2876	3051	props.put("fileExtension", ".txt");
2877		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
2878		+ filePath, props);
2879		Statement stmt = conn.createStatement();
2880
2881		StringWriter sw = new StringWriter();
2882		PrintWriter logger = new PrintWriter(sw, true);
2883		DriverManager.setLogWriter(logger);
2884
2885		ResultSet results = stmt.executeQuery("SELECT * FROM with_leading_trash");
2886		while (results.next())
2887		{
2888
2889		}
2890		String logMessages = sw.getBuffer().toString();
2891
2892		/*
2893		* Check that non-parseables lines were logged.
2894		*/
2895		assertTrue(logMessages.contains("Databank=MSW"));
2896		assertTrue(logMessages.contains("Locatie=DENH"));
	3052
	3053	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	3054	+ filePath, props);
	3055	Statement stmt = conn.createStatement())
	3056	{
	3057	StringWriter sw = new StringWriter();
	3058	PrintWriter logger = new PrintWriter(sw, true);
	3059	DriverManager.setLogWriter(logger);
	3060
	3061	try (ResultSet results = stmt.executeQuery("SELECT * FROM with_leading_trash"))
	3062	{
	3063	while (results.next())
	3064	{
	3065
	3066	}
	3067	}
	3068	String logMessages = sw.getBuffer().toString();
	3069
	3070	/*
	3071	* Check that non-parseables lines were logged.
	3072	*/
	3073	assertTrue(logMessages.contains("Databank=MSW"));
	3074	assertTrue(logMessages.contains("Locatie=DENH"));
	3075	}
2897	3076	}
2898	3077
2899	3078	@Test

2903	3082	props.put("separator", ":");
2904	3083	props.put("fileExtension", ".log");
2905	3084	props.put("missingValue", "$$");
2906		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
2907		+ filePath, props);
2908		Statement stmt = conn.createStatement();
2909		ResultSet results = stmt
2910		.executeQuery("SELECT * FROM recording-2015-06-28");
2911
2912		assertTrue(results.next());
2913		assertEquals("2015-01-01", results.getString(1));
2914		assertEquals("start", results.getString(2));
2915		assertEquals("$$", results.getString(3));
2916		assertEquals("$$", results.getString(4));
2917		assertTrue(results.next());
2918		assertEquals("2015-01-02", results.getString(1));
2919		assertEquals("new", results.getString(2));
2920		assertEquals("event", results.getString(3));
2921		assertEquals("$$", results.getString(4));
2922		assertTrue(results.next());
2923		assertEquals("2015-01-03", results.getString(1));
2924		assertEquals("repeat", results.getString(2));
2925		assertEquals("previous", results.getString(3));
2926		assertEquals("100", results.getString(4));
2927		assertFalse(results.next());
	3085
	3086	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	3087	+ filePath, props);
	3088	Statement stmt = conn.createStatement();
	3089	ResultSet results = stmt
	3090	.executeQuery("SELECT * FROM recording-2015-06-28"))
	3091	{
	3092	assertTrue(results.next());
	3093	assertEquals("2015-01-01", results.getString(1));
	3094	assertEquals("start", results.getString(2));
	3095	assertEquals("$$", results.getString(3));
	3096	assertEquals("$$", results.getString(4));
	3097	assertTrue(results.next());
	3098	assertEquals("2015-01-02", results.getString(1));
	3099	assertEquals("new", results.getString(2));
	3100	assertEquals("event", results.getString(3));
	3101	assertEquals("$$", results.getString(4));
	3102	assertTrue(results.next());
	3103	assertEquals("2015-01-03", results.getString(1));
	3104	assertEquals("repeat", results.getString(2));
	3105	assertEquals("previous", results.getString(3));
	3106	assertEquals("100", results.getString(4));
	3107	assertFalse(results.next());
	3108	}
2928	3109	}
2929	3110
2930	3111	@Test

2932	3113	{
2933	3114	Properties props = new Properties();
2934	3115	props.put("columnTypes", "Integer,String,Date,Time");
2935		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
2936
2937		Statement stmt = conn.createStatement();
2938
2939		ResultSet results = stmt.executeQuery("select ID, ID + 1, NAME, START_DATE, START_DATE + 1, START_TIME from bad_values");
2940		assertTrue(results.next());
2941
2942		/*
2943		* Check that SQL NULL is returned for empty or invalid numeric, date and time fields,
2944		* and that zero is returned from methods that return a number.
2945		*/
2946		assertEquals("ID is wrong", 0, results.getInt("ID"));
2947		assertTrue(results.wasNull());
2948		assertEquals("ID + 1 is wrong", 0, results.getInt(2));
2949		assertTrue(results.wasNull());
2950		assertEquals("NAME is wrong", "Simon", results.getString(3));
2951		assertFalse(results.wasNull());
2952		assertNull("START_DATE is wrong", results.getDate(4));
2953		assertTrue(results.wasNull());
2954		assertNull("START_DATE + 1 is wrong", results.getDate(5));
2955		assertTrue(results.wasNull());
2956		assertNull("START_TIME is wrong", results.getTime(6));
2957		assertTrue(results.wasNull());
2958
2959		assertTrue(results.next());
2960
2961		assertNull("ID is wrong", results.getObject("ID"));
2962		assertTrue(results.wasNull());
2963		assertNull("ID + 1 is wrong", results.getObject(2));
2964		assertTrue(results.wasNull());
2965		assertEquals("NAME is wrong", "Wally", results.getString(3));
2966		assertFalse(results.wasNull());
2967		assertNull("START_DATE is wrong", results.getObject(4));
2968		assertTrue(results.wasNull());
2969		assertNull("START_DATE + 1 is wrong", results.getObject(5));
2970		assertTrue(results.wasNull());
2971		assertNull("START_TIME is wrong", results.getObject(6));
2972		assertTrue(results.wasNull());
2973
2974		assertTrue(results.next());
	3116
	3117	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
	3118
	3119	Statement stmt = conn.createStatement();
	3120
	3121	ResultSet results = stmt.executeQuery("select ID, ID + 1, NAME, START_DATE, START_DATE + 1, START_TIME from bad_values"))
	3122	{
	3123	assertTrue(results.next());
	3124
	3125	/*
	3126	* Check that SQL NULL is returned for empty or invalid numeric, date and time fields,
	3127	* and that zero is returned from methods that return a number.
	3128	*/
	3129	assertEquals("ID is wrong", 0, results.getInt("ID"));
	3130	assertTrue(results.wasNull());
	3131	assertEquals("ID + 1 is wrong", 0, results.getInt(2));
	3132	assertTrue(results.wasNull());
	3133	assertEquals("NAME is wrong", "Simon", results.getString(3));
	3134	assertFalse(results.wasNull());
	3135	assertNull("START_DATE is wrong", results.getDate(4));
	3136	assertTrue(results.wasNull());
	3137	assertNull("START_DATE + 1 is wrong", results.getDate(5));
	3138	assertTrue(results.wasNull());
	3139	assertNull("START_TIME is wrong", results.getTime(6));
	3140	assertTrue(results.wasNull());
	3141
	3142	assertTrue(results.next());
	3143
	3144	assertNull("ID is wrong", results.getObject("ID"));
	3145	assertTrue(results.wasNull());
	3146	assertNull("ID + 1 is wrong", results.getObject(2));
	3147	assertTrue(results.wasNull());
	3148	assertEquals("NAME is wrong", "Wally", results.getString(3));
	3149	assertFalse(results.wasNull());
	3150	assertNull("START_DATE is wrong", results.getObject(4));
	3151	assertTrue(results.wasNull());
	3152	assertNull("START_DATE + 1 is wrong", results.getObject(5));
	3153	assertTrue(results.wasNull());
	3154	assertNull("START_TIME is wrong", results.getObject(6));
	3155	assertTrue(results.wasNull());
	3156
	3157	assertTrue(results.next());
	3158	}
2975	3159	}
2976	3160
2977	3161	@Test

2985	3169	props.put("fileTailPrepend", "True");
2986	3170	props.put("columnTypes", "String,Date,Time,String,Double");
2987	3171
2988		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
2989		+ filePath, props);
2990		Statement stmt = conn.createStatement();
2991
2992		ResultSet results = null;
2993		ResultSetMetaData metadata;
2994
2995		results = stmt.executeQuery("SELECT * FROM varlen1");
2996		metadata = results.getMetaData();
2997		assertEquals("file_date", metadata.getColumnName(1));
2998		assertEquals("Datum", metadata.getColumnName(2));
2999		assertEquals("Tijd", metadata.getColumnName(3));
3000		assertEquals("Station", metadata.getColumnName(4));
3001		assertEquals("P000", metadata.getColumnName(5));
3002		assertEquals("P001", metadata.getColumnName(6));
3003		assertEquals("P002", metadata.getColumnName(7));
3004		assertEquals("P003", metadata.getColumnName(8));
3005
3006		results = stmt.executeQuery("SELECT * FROM varlen2");
3007		metadata = results.getMetaData();
3008		assertEquals("file_date", metadata.getColumnName(1));
3009		assertEquals("Datum", metadata.getColumnName(2));
3010		assertEquals("Tijd", metadata.getColumnName(3));
3011		assertEquals("Station", metadata.getColumnName(4));
3012		assertEquals("P000", metadata.getColumnName(5));
3013		assertEquals("P001", metadata.getColumnName(6));
3014
3015		results = stmt.executeQuery("SELECT * FROM varlen1");
3016		assertTrue(results.next());
3017		assertEquals("007", results.getObject("Station"));
3018		assertEquals(new Double("26.54"), results.getObject("P003"));
3019		assertTrue(results.next());
3020		assertEquals("007", results.getObject("Station"));
3021		assertEquals(new Double("26.54"), results.getObject("P003"));
3022		assertTrue(results.next());
3023		assertEquals("007", results.getObject("Station"));
3024		assertEquals(new Double("26.54"), results.getObject("P003"));
3025		assertTrue(results.next());
3026		assertEquals("001", results.getObject("Station"));
3027		assertEquals(new Double("26.55"), results.getObject("P003"));
3028		assertFalse(results.next());
3029
3030		results = stmt.executeQuery("SELECT * FROM varlen2");
3031		assertTrue(results.next());
3032		assertEquals("007", results.getObject("Station"));
3033		assertTrue(results.next());
3034		assertEquals("007", results.getObject("Station"));
3035		assertTrue(results.next());
3036		assertEquals("013", results.getObject("Station"));
3037		assertTrue(results.next());
3038		assertEquals("013", results.getObject("Station"));
3039		assertFalse(results.next());
	3172	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	3173	+ filePath, props);
	3174	Statement stmt = conn.createStatement())
	3175	{
	3176	try (ResultSet results = stmt.executeQuery("SELECT * FROM varlen1"))
	3177	{
	3178	ResultSetMetaData metadata = results.getMetaData();
	3179	assertEquals("file_date", metadata.getColumnName(1));
	3180	assertEquals("Datum", metadata.getColumnName(2));
	3181	assertEquals("Tijd", metadata.getColumnName(3));
	3182	assertEquals("Station", metadata.getColumnName(4));
	3183	assertEquals("P000", metadata.getColumnName(5));
	3184	assertEquals("P001", metadata.getColumnName(6));
	3185	assertEquals("P002", metadata.getColumnName(7));
	3186	assertEquals("P003", metadata.getColumnName(8));
	3187	}
	3188
	3189	try (ResultSet results = stmt.executeQuery("SELECT * FROM varlen2"))
	3190	{
	3191	ResultSetMetaData metadata = results.getMetaData();
	3192	assertEquals("file_date", metadata.getColumnName(1));
	3193	assertEquals("Datum", metadata.getColumnName(2));
	3194	assertEquals("Tijd", metadata.getColumnName(3));
	3195	assertEquals("Station", metadata.getColumnName(4));
	3196	assertEquals("P000", metadata.getColumnName(5));
	3197	assertEquals("P001", metadata.getColumnName(6));
	3198	}
	3199
	3200	try (ResultSet results = stmt.executeQuery("SELECT * FROM varlen1"))
	3201	{
	3202	assertTrue(results.next());
	3203	assertEquals("007", results.getObject("Station"));
	3204	assertEquals(Double.valueOf("26.54"), results.getObject("P003"));
	3205	assertTrue(results.next());
	3206	assertEquals("007", results.getObject("Station"));
	3207	assertEquals(Double.valueOf("26.54"), results.getObject("P003"));
	3208	assertTrue(results.next());
	3209	assertEquals("007", results.getObject("Station"));
	3210	assertEquals(Double.valueOf("26.54"), results.getObject("P003"));
	3211	assertTrue(results.next());
	3212	assertEquals("001", results.getObject("Station"));
	3213	assertEquals(Double.valueOf("26.55"), results.getObject("P003"));
	3214	assertFalse(results.next());
	3215	}
	3216
	3217	try (ResultSet results = stmt.executeQuery("SELECT * FROM varlen2"))
	3218	{
	3219	assertTrue(results.next());
	3220	assertEquals("007", results.getObject("Station"));
	3221	assertTrue(results.next());
	3222	assertEquals("007", results.getObject("Station"));
	3223	assertTrue(results.next());
	3224	assertEquals("013", results.getObject("Station"));
	3225	assertTrue(results.next());
	3226	assertEquals("013", results.getObject("Station"));
	3227	assertFalse(results.next());
	3228	}
	3229	}
3040	3230	}
3041	3231
3042	3232	@Test

3049	3239	props.put("fileTailParts", "file_date");
3050	3240	props.put("fileTailPrepend", "True");
3051	3241
3052		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
3053		+ filePath, props);
3054		Statement stmt = conn.createStatement();
3055
3056		ResultSet results = null;
3057		ResultSetMetaData metadata = null;
3058
3059		results = stmt.executeQuery("SELECT * FROM varlen1");
3060		metadata = results.getMetaData();
3061		assertEquals("file_date", metadata.getColumnName(1));
3062		assertEquals("Datum", metadata.getColumnName(2));
3063		assertEquals("Tijd", metadata.getColumnName(3));
3064		assertEquals("Station", metadata.getColumnName(4));
3065		assertEquals("P000", metadata.getColumnName(5));
3066		assertEquals("P001", metadata.getColumnName(6));
3067		assertEquals("P002", metadata.getColumnName(7));
3068		assertEquals("P003", metadata.getColumnName(8));
3069
3070		results = stmt.executeQuery("SELECT * FROM varlen2");
3071		metadata = results.getMetaData();
3072		assertEquals("file_date", metadata.getColumnName(1));
3073		assertEquals("Datum", metadata.getColumnName(2));
3074		assertEquals("Tijd", metadata.getColumnName(3));
3075		assertEquals("Station", metadata.getColumnName(4));
3076		assertEquals("P000", metadata.getColumnName(5));
3077		assertEquals("P001", metadata.getColumnName(6));
	3242	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	3243	+ filePath, props);
	3244	Statement stmt = conn.createStatement())
	3245	{
	3246	try (ResultSet results = stmt.executeQuery("SELECT * FROM varlen1"))
	3247	{
	3248	ResultSetMetaData metadata = results.getMetaData();
	3249	assertEquals("file_date", metadata.getColumnName(1));
	3250	assertEquals("Datum", metadata.getColumnName(2));
	3251	assertEquals("Tijd", metadata.getColumnName(3));
	3252	assertEquals("Station", metadata.getColumnName(4));
	3253	assertEquals("P000", metadata.getColumnName(5));
	3254	assertEquals("P001", metadata.getColumnName(6));
	3255	assertEquals("P002", metadata.getColumnName(7));
	3256	assertEquals("P003", metadata.getColumnName(8));
	3257	}
	3258
	3259	try (ResultSet results = stmt.executeQuery("SELECT * FROM varlen2"))
	3260	{
	3261	ResultSetMetaData metadata = results.getMetaData();
	3262	assertEquals("file_date", metadata.getColumnName(1));
	3263	assertEquals("Datum", metadata.getColumnName(2));
	3264	assertEquals("Tijd", metadata.getColumnName(3));
	3265	assertEquals("Station", metadata.getColumnName(4));
	3266	assertEquals("P000", metadata.getColumnName(5));
	3267	assertEquals("P001", metadata.getColumnName(6));
	3268	}
	3269	}
3078	3270	}
3079	3271
3080	3272	@Test
3081	3273	public void testNonExistingTable() throws SQLException
3082	3274	{
3083		Statement stmt = DriverManager.getConnection(
3084		"jdbc:relique:csv:" + filePath).createStatement();
3085
3086		try
3087		{
3088		stmt.executeQuery("SELECT * FROM not_there");
3089		fail("Should not find the table 'not_there'");
3090		}
3091		catch (SQLException e)
3092		{
3093		assertEquals("java.sql.SQLException: " + CsvResources.getString("fileNotFound") + ": "
3094		+ filePath + File.separator + "not_there.csv", "" + e);
	3275	try (Connection conn = DriverManager.getConnection(
	3276	"jdbc:relique:csv:" + filePath);
	3277	Statement stmt = conn.createStatement())
	3278	{
	3279	try
	3280	{
	3281	stmt.executeQuery("SELECT * FROM not_there");
	3282	fail("Should not find the table 'not_there'");
	3283	}
	3284	catch (SQLException e)
	3285	{
	3286	assertEquals("java.sql.SQLException: " + CsvResources.getString("fileNotFound") + ": "
	3287	+ filePath + File.separator + "not_there.csv", "" + e);
	3288	}
3095	3289	}
3096	3290
3097	3291	Properties props = new Properties();
3098	3292	props.put("indexedFiles", "True");
3099	3293	props.put("fileTailPattern", "-([0-9]{8})");
3100	3294	props.put("fileTailParts", "file_date");
3101		stmt = DriverManager.getConnection("jdbc:relique:csv:" + filePath,
3102		props).createStatement();
3103
3104		ResultSet results = stmt.executeQuery("SELECT * FROM not_there");
3105		assertFalse("non existing indexed tables are seen as empty", results
	3295
	3296	try (Connection conn = DriverManager.getConnection(
	3297	"jdbc:relique:csv:" + filePath, props);
	3298	Statement stmt = conn.createStatement();
	3299	ResultSet results = stmt.executeQuery("SELECT * FROM not_there"))
	3300	{
	3301	assertFalse("non existing indexed tables are seen as empty", results
3106	3302	.next());
	3303	}
3107	3304	}
3108	3305
3109	3306	@Test

3112	3309	// no bug report, check discussion thread
3113	3310	// https://sourceforge.net/projects/csvjdbc/forums/forum/56965/topic/2608197
3114	3311	Properties props = new Properties();
3115		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
3116		+ filePath, props);
3117
3118		Statement stmt = conn.createStatement();
3119
3120		// load CSV driver
3121		try
3122		{
3123		stmt.executeQuery("SELECT * FROM duplicate_headers");
3124		fail("expected exception java.sql.SQLException: " + CsvResources.getString("duplicateColumns"));
3125		}
3126		catch (SQLException e)
3127		{
3128		assertEquals("wrong exception and/or exception text!",
3129		"java.sql.SQLException: " + CsvResources.getString("duplicateColumns"),
3130		"" + e);
	3312	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	3313	+ filePath, props);
	3314
	3315	Statement stmt = conn.createStatement())
	3316	{
	3317	// load CSV driver
	3318	try
	3319	{
	3320	stmt.executeQuery("SELECT * FROM duplicate_headers");
	3321	fail("expected exception java.sql.SQLException: " + CsvResources.getString("duplicateColumns"));
	3322	}
	3323	catch (SQLException e)
	3324	{
	3325	assertEquals("wrong exception and/or exception text!",
	3326	"java.sql.SQLException: " + CsvResources.getString("duplicateColumns"),
	3327	"" + e);
	3328	}
3131	3329	}
3132	3330	}
3133	3331

3140	3338	props.put("suppressHeaders", "true");
3141	3339	props.put("skipLeadingLines", "1");
3142	3340
3143		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
3144		+ filePath, props);
3145
3146		Statement stmt = conn.createStatement();
3147
3148		ResultSet results = stmt
3149		.executeQuery("SELECT * FROM duplicate_headers");
3150
3151		assertTrue(results.next());
3152		assertEquals("1:ID is wrong", "1", results.getString(1));
3153		assertEquals("2:ID is wrong", "2", results.getString(2));
3154		assertEquals("3:ID is wrong", "george", results.getString(3));
3155		assertEquals("4:ID is wrong", "joe", results.getString(4));
3156
3157		assertTrue(results.next());
3158		assertEquals("1:ID is wrong", "2", results.getString(1));
3159		assertEquals("2:ID is wrong", "2", results.getString(2));
3160		assertEquals("3:ID is wrong", "aworth", results.getString(3));
3161		assertEquals("4:ID is wrong", "smith", results.getString(4));
3162
3163		assertFalse(results.next());
	3341	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	3342	+ filePath, props);
	3343
	3344	Statement stmt = conn.createStatement();
	3345
	3346	ResultSet results = stmt
	3347	.executeQuery("SELECT * FROM duplicate_headers"))
	3348	{
	3349	assertTrue(results.next());
	3350	assertEquals("1:ID is wrong", "1", results.getString(1));
	3351	assertEquals("2:ID is wrong", "2", results.getString(2));
	3352	assertEquals("3:ID is wrong", "george", results.getString(3));
	3353	assertEquals("4:ID is wrong", "joe", results.getString(4));
	3354
	3355	assertTrue(results.next());
	3356	assertEquals("1:ID is wrong", "2", results.getString(1));
	3357	assertEquals("2:ID is wrong", "2", results.getString(2));
	3358	assertEquals("3:ID is wrong", "aworth", results.getString(3));
	3359	assertEquals("4:ID is wrong", "smith", results.getString(4));
	3360
	3361	assertFalse(results.next());
	3362	}
3164	3363	}
3165	3364
3166	3365	/**
3167	3366	* This creates several sentences with where and tests they work
3168		*
	3367	*
3169	3368	* @throws SQLException
3170	3369	*/
3171	3370	@Test

3175	3374	props.put("separator", ";");
3176	3375	props.put("quotechar", "'");
3177	3376
3178		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
3179		+ filePath, props);
3180
3181		Statement stmt = conn.createStatement();
3182
3183		ResultSet results = stmt.executeQuery("SELECT * FROM doublequoted");
3184		assertTrue(results.next());
3185		assertEquals(
3186		"\"Rechtsform unbekannt\" entsteht durch die Simulation zTELKUS. Es werden Simulationsregeln angewandt.",
3187		results.getString(10));
	3377	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	3378	+ filePath, props);
	3379
	3380	Statement stmt = conn.createStatement();
	3381
	3382	ResultSet results = stmt.executeQuery("SELECT * FROM doublequoted"))
	3383	{
	3384	assertTrue(results.next());
	3385	assertEquals(
	3386	"\"Rechtsform unbekannt\" entsteht durch die Simulation zTELKUS. Es werden Simulationsregeln angewandt.",
	3387	results.getString(10));
	3388	}
3188	3389	}
3189	3390
3190	3391	@Test

3196	3397	props.put("quotestyle", "SQL");
3197	3398	props.put("commentChar", "C");
3198	3399
3199		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
3200		+ filePath, props);
3201
3202		Statement stmt = conn.createStatement();
3203
3204		ResultSet results = stmt.executeQuery("SELECT * FROM doublequoted");
3205		assertTrue(results.next());
3206		assertEquals(
3207		"\"Rechtsform unbekannt\" entsteht durch die Simulation zTELKUS. Es werden Simulationsregeln angewandt.",
3208		results.getString(10));
	3400	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	3401	+ filePath, props);
	3402
	3403	Statement stmt = conn.createStatement();
	3404
	3405	ResultSet results = stmt.executeQuery("SELECT * FROM doublequoted"))
	3406	{
	3407	assertTrue(results.next());
	3408	assertEquals(
	3409	"\"Rechtsform unbekannt\" entsteht durch die Simulation zTELKUS. Es werden Simulationsregeln angewandt.",
	3410	results.getString(10));
	3411	}
3209	3412	}
3210	3413
3211	3414	@Test

3216	3419	props.put("quotechar", "'");
3217	3420	props.put("quoteStyle", "C");
3218	3421
3219		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
3220		+ filePath, props);
3221
3222		Statement stmt = conn.createStatement();
3223
3224		ResultSet results = stmt.executeQuery("SELECT * FROM doublequoted");
3225		// TODO: this should actually fail! have a look at testEscapingQuotecharExplicitSQLStyle for the way to check an exception.
3226		assertTrue(results.next());
3227		assertEquals(
3228		"\"Rechtsform unbekannt\" entsteht durch die Simulation zTELKUS. Es werden Simulationsregeln angewandt.",
3229		results.getString(10));
	3422	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	3423	+ filePath, props);
	3424
	3425	Statement stmt = conn.createStatement();
	3426
	3427	ResultSet results = stmt.executeQuery("SELECT * FROM doublequoted"))
	3428	{
	3429	// TODO: this should actually fail! have a look at testEscapingQuotecharExplicitSQLStyle for the way to check an exception.
	3430	assertTrue(results.next());
	3431	assertEquals(
	3432	"\"Rechtsform unbekannt\" entsteht durch die Simulation zTELKUS. Es werden Simulationsregeln angewandt.",
	3433	results.getString(10));
	3434	}
3230	3435	}
3231	3436
3232	3437	@Test

3237	3442	props.put("quotechar", "'");
3238	3443	props.put("quoteStyle", "C");
3239	3444
3240		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
3241		+ filePath, props);
3242
3243		Statement stmt = conn.createStatement();
3244
3245		ResultSet results = stmt.executeQuery("SELECT F1 FROM doublequoted");
3246		assertTrue(results.next());
3247		assertTrue(results.next());
3248		assertEquals("doubling \"\"quotechar", results.getObject("F1"));
3249		assertTrue(results.next());
3250		assertEquals("escaping quotechar\"", results.getObject("F1"));
	3445	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	3446	+ filePath, props);
	3447
	3448	Statement stmt = conn.createStatement();
	3449
	3450	ResultSet results = stmt.executeQuery("SELECT F1 FROM doublequoted"))
	3451	{
	3452	assertTrue(results.next());
	3453	assertTrue(results.next());
	3454	assertEquals("doubling \"\"quotechar", results.getObject("F1"));
	3455	assertTrue(results.next());
	3456	assertEquals("escaping quotechar\"", results.getObject("F1"));
	3457	}
3251	3458	}
3252	3459
3253	3460	@Test

3258	3465	props.put("quotechar", "'");
3259	3466	props.put("quoteStyle", "SQL");
3260	3467
3261		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
3262		+ filePath, props);
3263
3264		Statement stmt = conn.createStatement();
3265
3266		ResultSet results = stmt.executeQuery("SELECT F1 FROM doublequoted");
3267		assertTrue(results.next());
3268		assertTrue(results.next());
3269		assertEquals("doubling \\\"\\\"quotechar", results.getObject("F1"));
3270		assertTrue(results.next());
3271		assertTrue(results.next());
3272		try
3273		{
3274		results.next();
3275		fail("Should raise a java.sqlSQLException");
3276		}
3277		catch (SQLException e)
3278		{
3279		assertEquals("java.sql.SQLException: " + CsvResources.getString("eofInQuotes") + ": 6", "" + e);
	3468	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	3469	+ filePath, props);
	3470
	3471	Statement stmt = conn.createStatement();
	3472
	3473	ResultSet results = stmt.executeQuery("SELECT F1 FROM doublequoted"))
	3474	{
	3475	assertTrue(results.next());
	3476	assertTrue(results.next());
	3477	assertEquals("doubling \\\"\\\"quotechar", results.getObject("F1"));
	3478	assertTrue(results.next());
	3479	assertTrue(results.next());
	3480	try
	3481	{
	3482	results.next();
	3483	fail("Should raise a java.sqlSQLException");
	3484	}
	3485	catch (SQLException e)
	3486	{
	3487	assertEquals("java.sql.SQLException: " + CsvResources.getString("eofInQuotes") + ": 6", "" + e);
	3488	}
3280	3489	}
3281	3490	}
3282	3491

3286	3495	Properties props = new Properties();
3287	3496	props.put("quotechar", "()");
3288	3497
3289		try
3290		{
3291		DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
	3498	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props))
	3499	{
3292	3500	fail("expected exception java.sql.SQLException");
3293	3501	}
3294	3502	catch (SQLException e)

3305	3513	props.put("quotechar", "");
3306	3514	props.put("fileExtension", ".txt");
3307	3515
3308		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
3309		+ filePath, props);
3310
3311		Statement stmt = conn.createStatement();
3312
3313		ResultSet results = stmt.executeQuery("SELECT * FROM uses_quotes");
3314		assertTrue(results.next());
3315		assertEquals("COLUMN1 is wrong", "1", results.getString(1));
3316		assertEquals("COLUMN2 is wrong", "uno", results.getString(2));
3317		assertEquals("COLUMN3 is wrong", "one", results.getString(3));
3318		assertTrue(results.next());
3319		assertEquals("COLUMN1 is wrong", "2", results.getString(1));
3320		assertEquals("COLUMN2 is wrong", "a 'quote' (source unknown)", results.getString(2));
3321		assertEquals("COLUMN3 is wrong", "two", results.getString(3));
3322		assertTrue(results.next());
3323		assertEquals("COLUMN1 is wrong", "3", results.getString(1));
3324		assertEquals("COLUMN2 is wrong", "another \"quote\" (also unkown)", results.getString(2));
3325		assertEquals("COLUMN3 is wrong", "three", results.getString(3));
	3516	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	3517	+ filePath, props);
	3518
	3519	Statement stmt = conn.createStatement();
	3520
	3521	ResultSet results = stmt.executeQuery("SELECT * FROM uses_quotes"))
	3522	{
	3523	assertTrue(results.next());
	3524	assertEquals("COLUMN1 is wrong", "1", results.getString(1));
	3525	assertEquals("COLUMN2 is wrong", "uno", results.getString(2));
	3526	assertEquals("COLUMN3 is wrong", "one", results.getString(3));
	3527	assertTrue(results.next());
	3528	assertEquals("COLUMN1 is wrong", "2", results.getString(1));
	3529	assertEquals("COLUMN2 is wrong", "a 'quote' (source unknown)", results.getString(2));
	3530	assertEquals("COLUMN3 is wrong", "two", results.getString(3));
	3531	assertTrue(results.next());
	3532	assertEquals("COLUMN1 is wrong", "3", results.getString(1));
	3533	assertEquals("COLUMN2 is wrong", "another \"quote\" (also unkown)", results.getString(2));
	3534	assertEquals("COLUMN3 is wrong", "three", results.getString(3));
	3535	}
3326	3536	}
3327	3537
3328	3538	@Test

3331	3541	Properties props = new Properties();
3332	3542	props.put("separator", "#@");
3333	3543	props.put("skipLeadingLines", "2");
3334		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
3335		+ filePath, props);
3336		Statement stmt = conn.createStatement();
3337		ResultSet results = stmt.executeQuery("SELECT * FROM evonix");
3338
3339		ResultSetMetaData metadata = results.getMetaData();
3340		assertEquals("ID", metadata.getColumnName(1));
3341		assertEquals("Name", metadata.getColumnName(2));
3342		assertEquals("Birthday", metadata.getColumnName(3));
3343		assertTrue(results.next());
3344		assertEquals("1:ID is wrong", "0", results.getString(1));
3345		assertEquals("2:Name is wrong", "(Florian)", results.getString(2));
3346		assertEquals("3:Birthday is wrong", "01.01.1990", results.getString(3));
3347		assertTrue(results.next());
3348		assertEquals("1:ID is wrong", "1", results.getString(1));
3349		assertEquals("2:Name is wrong", "(Tobias)", results.getString(2));
3350		assertEquals("3:Birthday is wrong", "01.01.1990", results.getString(3));
3351		assertTrue(results.next());
3352		assertEquals("1:ID is wrong", "2", results.getString(1));
3353		assertEquals("2:Name is wrong", "(#Mark)", results.getString(2));
3354		assertEquals("3:Birthday is wrong", "01.01.1990", results.getString(3));
3355		assertTrue(results.next());
3356		assertEquals("1:ID is wrong", "3", results.getString(1));
3357		assertEquals("2:Name is wrong", "(@Jason)", results.getString(2));
3358		assertEquals("3:Birthday is wrong", "01.01.1990", results.getString(3));
3359		assertTrue(results.next());
3360		assertEquals("1:ID is wrong", "4", results.getString(1));
3361		assertEquals("2:Name is wrong", "Robert", results.getString(2));
3362		assertEquals("3:Birthday is wrong", "01.01.1990", results.getString(3));
3363		assertFalse(results.next());
	3544
	3545	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	3546	+ filePath, props);
	3547	Statement stmt = conn.createStatement();
	3548	ResultSet results = stmt.executeQuery("SELECT * FROM evonix"))
	3549	{
	3550	ResultSetMetaData metadata = results.getMetaData();
	3551	assertEquals("ID", metadata.getColumnName(1));
	3552	assertEquals("Name", metadata.getColumnName(2));
	3553	assertEquals("Birthday", metadata.getColumnName(3));
	3554	assertTrue(results.next());
	3555	assertEquals("1:ID is wrong", "0", results.getString(1));
	3556	assertEquals("2:Name is wrong", "(Florian)", results.getString(2));
	3557	assertEquals("3:Birthday is wrong", "01.01.1990", results.getString(3));
	3558	assertTrue(results.next());
	3559	assertEquals("1:ID is wrong", "1", results.getString(1));
	3560	assertEquals("2:Name is wrong", "(Tobias)", results.getString(2));
	3561	assertEquals("3:Birthday is wrong", "01.01.1990", results.getString(3));
	3562	assertTrue(results.next());
	3563	assertEquals("1:ID is wrong", "2", results.getString(1));
	3564	assertEquals("2:Name is wrong", "(#Mark)", results.getString(2));
	3565	assertEquals("3:Birthday is wrong", "01.01.1990", results.getString(3));
	3566	assertTrue(results.next());
	3567	assertEquals("1:ID is wrong", "3", results.getString(1));
	3568	assertEquals("2:Name is wrong", "(@Jason)", results.getString(2));
	3569	assertEquals("3:Birthday is wrong", "01.01.1990", results.getString(3));
	3570	assertTrue(results.next());
	3571	assertEquals("1:ID is wrong", "4", results.getString(1));
	3572	assertEquals("2:Name is wrong", "Robert", results.getString(2));
	3573	assertEquals("3:Birthday is wrong", "01.01.1990", results.getString(3));
	3574	assertFalse(results.next());
	3575	}
3364	3576	}
3365	3577
3366	3578	@Test

3369	3581	Properties props = new Properties();
3370	3582	props.put("separator", "#@");
3371	3583	props.put("commentChar", "rem");
3372		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
3373		+ filePath, props);
3374		Statement stmt = conn.createStatement();
3375		ResultSet results = stmt.executeQuery("SELECT * FROM evonix");
3376
3377		ResultSetMetaData metadata = results.getMetaData();
3378		assertEquals("ID", metadata.getColumnName(1));
3379		assertEquals("Name", metadata.getColumnName(2));
3380		assertEquals("Birthday", metadata.getColumnName(3));
3381		assertTrue(results.next());
3382		assertEquals("1:ID is wrong", "0", results.getString(1));
3383		assertEquals("2:Name is wrong", "(Florian)", results.getString(2));
3384		assertEquals("3:Birthday is wrong", "01.01.1990", results.getString(3));
	3584
	3585	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	3586	+ filePath, props);
	3587	Statement stmt = conn.createStatement();
	3588	ResultSet results = stmt.executeQuery("SELECT * FROM evonix"))
	3589	{
	3590	ResultSetMetaData metadata = results.getMetaData();
	3591	assertEquals("ID", metadata.getColumnName(1));
	3592	assertEquals("Name", metadata.getColumnName(2));
	3593	assertEquals("Birthday", metadata.getColumnName(3));
	3594	assertTrue(results.next());
	3595	assertEquals("1:ID is wrong", "0", results.getString(1));
	3596	assertEquals("2:Name is wrong", "(Florian)", results.getString(2));
	3597	assertEquals("3:Birthday is wrong", "01.01.1990", results.getString(3));
	3598	}
3385	3599	}
3386	3600
3387	3601	@Test

3390	3604	Properties props = new Properties();
3391	3605	props.put("commentChar", "#");
3392	3606	props.put("fileExtension", ".txt");
3393		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
3394		+ filePath, props);
3395		Statement stmt = conn.createStatement();
3396		ResultSet results = stmt.executeQuery("SELECT * FROM nodata");
3397
3398		ResultSetMetaData metadata = results.getMetaData();
3399		assertEquals("Aleph", metadata.getColumnName(1));
3400		assertEquals("Beth", metadata.getColumnName(2));
3401		assertEquals("Ghimel", metadata.getColumnName(3));
3402		assertEquals("Daleth", metadata.getColumnName(4));
3403
3404		assertFalse(results.next());
	3607
	3608	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	3609	+ filePath, props);
	3610	Statement stmt = conn.createStatement();
	3611	ResultSet results = stmt.executeQuery("SELECT * FROM nodata"))
	3612	{
	3613	ResultSetMetaData metadata = results.getMetaData();
	3614	assertEquals("Aleph", metadata.getColumnName(1));
	3615	assertEquals("Beth", metadata.getColumnName(2));
	3616	assertEquals("Ghimel", metadata.getColumnName(3));
	3617	assertEquals("Daleth", metadata.getColumnName(4));
	3618
	3619	assertFalse(results.next());
	3620	}
3405	3621	}
3406	3622
3407	3623	@Test

3410	3626	Properties props = new Properties();
3411	3627	props.put("commentChar", "#");
3412	3628	props.put("fileExtension", ".txt");
3413		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
3414		+ filePath, props);
3415		Statement stmt = conn.createStatement();
3416		ResultSet results = stmt.executeQuery("SELECT * FROM only_comments");
3417		assertFalse(results.next());
	3629
	3630	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	3631	+ filePath, props);
	3632	Statement stmt = conn.createStatement();
	3633	ResultSet results = stmt.executeQuery("SELECT * FROM only_comments"))
	3634	{
	3635	assertFalse(results.next());
	3636	}
3418	3637	}
3419	3638
3420	3639	@Test
3421	3640	public void testConnectionName() throws SQLException
3422	3641	{
3423		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	3642	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	3643	+ filePath))
	3644	{
	3645	String url = conn.getMetaData().getURL();
	3646	assertTrue(url.startsWith("jdbc:relique:csv:"));
	3647	assertTrue(url.endsWith(File.separator + "testdata" + File.separator) \|\| url.endsWith(File.separator + "testdata"));
	3648	}
	3649	}
	3650
	3651	@Test
	3652	public void testConnectionClosed() throws SQLException
	3653	{
	3654	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	3655	+ filePath))
	3656	{
	3657	assertTrue(conn.isValid(0));
	3658	assertFalse(conn.isClosed());
	3659	conn.close();
	3660	assertTrue(conn.isClosed());
	3661	assertFalse(conn.isValid(0));
	3662
	3663	/*
	3664	* Second close is ignored.
	3665	*/
	3666	conn.close();
	3667	try
	3668	{
	3669	conn.createStatement();
	3670	fail("expected exception java.sql.SQLException");
	3671	}
	3672	catch (SQLException e)
	3673	{
	3674	assertEquals("wrong exception and/or exception text!",
	3675	"java.sql.SQLException: " + CsvResources.getString("closedConnection"), "" + e);
	3676	}
	3677	}
	3678	}
	3679
	3680	@Test
	3681	public void testStatementClosed() throws SQLException
	3682	{
	3683	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
3424	3684	+ filePath);
3425		String url = conn.getMetaData().getURL();
3426		assertTrue(url.startsWith("jdbc:relique:csv:"));
3427		assertTrue(url.endsWith(File.separator + "testdata" + File.separator) \|\| url.endsWith(File.separator + "testdata"));
3428		}
3429
3430		@Test
3431		public void testConnectionClosed() throws SQLException
3432		{
3433		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	3685	Statement stmt = conn.createStatement())
	3686	{
	3687	assertFalse(stmt.isClosed());
	3688	stmt.close();
	3689	assertTrue(stmt.isClosed());
	3690
	3691	/*
	3692	* Second close is ignored.
	3693	*/
	3694	stmt.close();
	3695
	3696	try
	3697	{
	3698	stmt.executeQuery("SELECT * FROM sample");
	3699	fail("expected exception java.sql.SQLException");
	3700	}
	3701	catch (SQLException e)
	3702	{
	3703	assertEquals("wrong exception and/or exception text!",
	3704	"java.sql.SQLException: " + CsvResources.getString("statementClosed"), "" + e);
	3705	}
	3706	}
	3707	}
	3708
	3709	@Test
	3710	public void testConnectionClosesStatements() throws SQLException
	3711	{
	3712	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
3434	3713	+ filePath);
3435		assertTrue(conn.isValid(0));
3436		assertFalse(conn.isClosed());
3437		conn.close();
3438		assertTrue(conn.isClosed());
3439		assertFalse(conn.isValid(0));
3440
3441		/*
3442		* Second close is ignored.
3443		*/
3444		conn.close();
3445		try
3446		{
3447		conn.createStatement();
3448		fail("expected exception java.sql.SQLException");
3449		}
3450		catch (SQLException e)
3451		{
3452		assertEquals("wrong exception and/or exception text!",
3453		"java.sql.SQLException: " + CsvResources.getString("closedConnection"), "" + e);
3454		}
3455		}
3456
3457		@Test
3458		public void testStatementClosed() throws SQLException
3459		{
3460		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	3714	Statement stmt1 = conn.createStatement();
	3715	Statement stmt2 = conn.createStatement();
	3716	Statement stmt3 = conn.createStatement();
	3717	Statement stmt4 = conn.createStatement())
	3718	{
	3719	conn.close();
	3720
	3721	assertTrue(stmt1.isClosed());
	3722	assertTrue(stmt2.isClosed());
	3723	assertTrue(stmt3.isClosed());
	3724	assertTrue(stmt4.isClosed());
	3725	}
	3726	}
	3727
	3728	@Test
	3729	public void testStatementCancelled() throws SQLException
	3730	{
	3731	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
3461	3732	+ filePath);
3462		Statement stmt = conn.createStatement();
3463		assertFalse(stmt.isClosed());
3464		stmt.close();
3465		assertTrue(stmt.isClosed());
3466
3467		/*
3468		* Second close is ignored.
3469		*/
3470		stmt.close();
3471
3472		try
3473		{
3474		stmt.executeQuery("SELECT * FROM sample");
3475		fail("expected exception java.sql.SQLException");
3476		}
3477		catch (SQLException e)
3478		{
3479		assertEquals("wrong exception and/or exception text!",
3480		"java.sql.SQLException: " + CsvResources.getString("statementClosed"), "" + e);
3481		}
3482		}
3483
3484		@Test
3485		public void testConnectionClosesStatements() throws SQLException
3486		{
3487		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
3488		+ filePath);
3489		Statement stmt1 = conn.createStatement();
3490		Statement stmt2 = conn.createStatement();
3491		Statement stmt3 = conn.createStatement();
3492		Statement stmt4 = conn.createStatement();
3493
3494		conn.close();
3495
3496		assertTrue(stmt1.isClosed());
3497		assertTrue(stmt2.isClosed());
3498		assertTrue(stmt3.isClosed());
3499		assertTrue(stmt4.isClosed());
3500		}
3501
3502		@Test
3503		public void testStatementCancelled() throws SQLException
3504		{
3505		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
3506		+ filePath);
3507		Statement stmt = conn.createStatement();
3508
3509		try
3510		{
3511		ResultSet results = stmt.executeQuery("SELECT * FROM sample");
3512		stmt.cancel();
3513		results.next();
3514		fail("expected exception java.sql.SQLException: Statement cancelled");
3515		}
3516		catch (SQLException e)
3517		{
3518		assertEquals("wrong exception and/or exception text!",
3519		"java.sql.SQLException: " + CsvResources.getString("statementCancelled"),
3520		"" + e);
3521		}
3522
3523		conn.close();
	3733	Statement stmt = conn.createStatement())
	3734	{
	3735	try
	3736	{
	3737	try (ResultSet results = stmt.executeQuery("SELECT * FROM sample"))
	3738	{
	3739	stmt.cancel();
	3740	results.next();
	3741	}
	3742	fail("expected exception java.sql.SQLException: Statement cancelled");
	3743	}
	3744	catch (SQLException e)
	3745	{
	3746	assertEquals("wrong exception and/or exception text!",
	3747	"java.sql.SQLException: " + CsvResources.getString("statementCancelled"),
	3748	"" + e);
	3749	}
	3750	}
3524	3751	}
3525	3752
3526	3753	@Test

3530	3757	props.put("trimHeaders", "true");
3531	3758	props.put("trimValues", "true");
3532	3759
3533		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
3534		+ filePath, props);
3535		Statement stmt = conn.createStatement();
3536		ResultSet results = stmt.executeQuery("SELECT * FROM foodstuffs");
3537
3538		ResultSetMetaData metadata = results.getMetaData();
3539		assertEquals("Column Count", 2, metadata.getColumnCount());
3540		assertEquals("Column Name 1", "key", metadata.getColumnName(1));
3541		assertEquals("Column Name 2", "value", metadata.getColumnName(2));
3542
3543		assertTrue(results.next());
3544		assertEquals("Row 1 key", "orange", results.getString(1));
3545		assertEquals("Row 1 value", "fruit", results.getString(2));
3546
3547		assertTrue(results.next());
3548		assertEquals("Row 2 key", "apple", results.getString(1));
3549		assertEquals("Row 2 value", "fruit", results.getString(2));
3550
3551		assertTrue(results.next());
3552		assertEquals("Row 3 key", "corn", results.getString(1));
3553		assertEquals("Row 3 value", "vegetable", results.getString(2));
3554
3555		assertTrue(results.next());
3556		assertEquals("Row 4 key", "lemon", results.getString(1));
3557		assertEquals("Row 4 value", "fruit", results.getString(2));
3558
3559		assertTrue(results.next());
3560		assertEquals("Row 5 key", "tomato", results.getString(1));
3561		assertEquals("Row 5 value", "who knows?", results.getString(2));
3562
3563		assertTrue(results.next());
3564		assertEquals("Row 6 key", " - ", results.getString(1));
3565		assertEquals("Row 6 value", " - ", results.getString(2));
3566
3567		assertFalse(results.next());
	3760	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	3761	+ filePath, props);
	3762	Statement stmt = conn.createStatement();
	3763	ResultSet results = stmt.executeQuery("SELECT * FROM foodstuffs"))
	3764	{
	3765	ResultSetMetaData metadata = results.getMetaData();
	3766	assertEquals("Column Count", 2, metadata.getColumnCount());
	3767	assertEquals("Column Name 1", "key", metadata.getColumnName(1));
	3768	assertEquals("Column Name 2", "value", metadata.getColumnName(2));
	3769
	3770	assertTrue(results.next());
	3771	assertEquals("Row 1 key", "orange", results.getString(1));
	3772	assertEquals("Row 1 value", "fruit", results.getString(2));
	3773
	3774	assertTrue(results.next());
	3775	assertEquals("Row 2 key", "apple", results.getString(1));
	3776	assertEquals("Row 2 value", "fruit", results.getString(2));
	3777
	3778	assertTrue(results.next());
	3779	assertEquals("Row 3 key", "corn", results.getString(1));
	3780	assertEquals("Row 3 value", "vegetable", results.getString(2));
	3781
	3782	assertTrue(results.next());
	3783	assertEquals("Row 4 key", "lemon", results.getString(1));
	3784	assertEquals("Row 4 value", "fruit", results.getString(2));
	3785
	3786	assertTrue(results.next());
	3787	assertEquals("Row 5 key", "tomato", results.getString(1));
	3788	assertEquals("Row 5 value", "who knows?", results.getString(2));
	3789
	3790	assertTrue(results.next());
	3791	assertEquals("Row 6 key", " - ", results.getString(1));
	3792	assertEquals("Row 6 value", " - ", results.getString(2));
	3793
	3794	assertFalse(results.next());
	3795	}
3568	3796	}
3569	3797
3570	3798	/**
3571	3799	* you can access columns that do not have a name by number
3572		*
	3800	*
3573	3801	* @throws SQLException
3574	3802	* @throws ParseException
3575	3803	*/

3579	3807	Properties props = new Properties();
3580	3808	props.put("fileExtension", ".txt");
3581	3809	//props.put("defectiveHeaders", "True");
3582
3583		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
3584		+ filePath, props);
3585		Statement stmt = conn.createStatement();
3586		ResultSet results = stmt.executeQuery("SELECT * FROM twoheaders");
3587
3588		ResultSetMetaData metadata = results.getMetaData();
3589
3590		assertEquals("Empty Column Name 1", "", metadata.getColumnName(1));
3591
3592		assertTrue(results.next());
3593		assertEquals("1 is wrong", "", results.getString(1));
3594		try
3595		{
3596		results.getString("");
3597		fail("expected exception java.sql.SQLException: Can't access columns with empty name by name");
3598		}
3599		catch (SQLException e)
3600		{
3601		assertEquals("wrong exception and/or exception text!",
3602		"java.sql.SQLException: " + CsvResources.getString("invalidColumnName") + ": ",
3603		"" + e);
3604		}
3605
3606		assertEquals("2 is wrong", "WNS925", results.getString(2));
3607		assertEquals("2 is wrong", "WNS925", results.getString("600-P1201"));
3608
3609		assertTrue(results.next());
3610		assertEquals("1 is wrong", "2010-02-21 00:00:00", results.getObject(1));
3611		assertEquals("2 is wrong", "21", results.getString(2));
3612		assertEquals("3 is wrong", "20", results.getString(3));
	3810
	3811	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	3812	+ filePath, props);
	3813	Statement stmt = conn.createStatement();
	3814	ResultSet results = stmt.executeQuery("SELECT * FROM twoheaders"))
	3815	{
	3816	ResultSetMetaData metadata = results.getMetaData();
	3817
	3818	assertEquals("Empty Column Name 1", "", metadata.getColumnName(1));
	3819
	3820	assertTrue(results.next());
	3821	assertEquals("1 is wrong", "", results.getString(1));
	3822	try
	3823	{
	3824	results.getString("");
	3825	fail("expected exception java.sql.SQLException: Can't access columns with empty name by name");
	3826	}
	3827	catch (SQLException e)
	3828	{
	3829	assertEquals("wrong exception and/or exception text!",
	3830	"java.sql.SQLException: " + CsvResources.getString("invalidColumnName") + ": ",
	3831	"" + e);
	3832	}
	3833
	3834	assertEquals("2 is wrong", "WNS925", results.getString(2));
	3835	assertEquals("2 is wrong", "WNS925", results.getString("600-P1201"));
	3836
	3837	assertTrue(results.next());
	3838	assertEquals("1 is wrong", "2010-02-21 00:00:00", results.getObject(1));
	3839	assertEquals("2 is wrong", "21", results.getString(2));
	3840	assertEquals("3 is wrong", "20", results.getString(3));
	3841	}
3613	3842	}
3614	3843
3615	3844	@Test

3618	3847	Properties props = new Properties();
3619	3848	props.put("fileExtension", ".txt");
3620	3849	props.put("defectiveHeaders", "True");
3621
3622		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
3623		+ filePath, props);
3624		Statement stmt = conn.createStatement();
3625		ResultSet results = stmt.executeQuery("SELECT * FROM twoheaders");
3626
3627		ResultSetMetaData metadata = results.getMetaData();
3628
3629		assertEquals("Incorrect Column Name 1", "COLUMN1", metadata.getColumnName(1));
3630		assertEquals("Incorrect Column Name 2", "600-P1201", metadata.getColumnName(2));
3631
3632		assertTrue(results.next());
3633		assertEquals("1 is wrong", "", results.getString(1));
3634		assertEquals("1 is wrong", "", results.getString("COLUMN1"));
3635
3636		assertEquals("2 is wrong", "WNS925", results.getString(2));
3637		assertEquals("2 is wrong", "WNS925", results.getString("600-P1201"));
3638
3639		assertTrue(results.next());
3640		assertEquals("1 is wrong", "2010-02-21 00:00:00", results.getObject(1));
3641		assertEquals("1 is wrong", "2010-02-21 00:00:00", results.getObject("COLUMN1"));
3642		assertEquals("2 is wrong", "21", results.getObject(2));
3643		assertEquals("3 is wrong", "20", results.getObject(3));
	3850
	3851	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	3852	+ filePath, props);
	3853	Statement stmt = conn.createStatement();
	3854	ResultSet results = stmt.executeQuery("SELECT * FROM twoheaders"))
	3855	{
	3856	ResultSetMetaData metadata = results.getMetaData();
	3857
	3858	assertEquals("Incorrect Column Name 1", "COLUMN1", metadata.getColumnName(1));
	3859	assertEquals("Incorrect Column Name 2", "600-P1201", metadata.getColumnName(2));
	3860
	3861	assertTrue(results.next());
	3862	assertEquals("1 is wrong", "", results.getString(1));
	3863	assertEquals("1 is wrong", "", results.getString("COLUMN1"));
	3864
	3865	assertEquals("2 is wrong", "WNS925", results.getString(2));
	3866	assertEquals("2 is wrong", "WNS925", results.getString("600-P1201"));
	3867
	3868	assertTrue(results.next());
	3869	assertEquals("1 is wrong", "2010-02-21 00:00:00", results.getObject(1));
	3870	assertEquals("1 is wrong", "2010-02-21 00:00:00", results.getObject("COLUMN1"));
	3871	assertEquals("2 is wrong", "21", results.getObject(2));
	3872	assertEquals("3 is wrong", "20", results.getObject(3));
	3873	}
3644	3874	}
3645	3875
3646	3876	@Test

3648	3878	{
3649	3879	Properties props = new Properties();
3650	3880	props.put("defectiveHeaders", "True");
3651
3652		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
3653		+ filePath, props);
3654		Statement stmt = conn.createStatement();
3655		ResultSet results = stmt.executeQuery("SELECT * FROM defectiveheader");
3656
3657		ResultSetMetaData metadata = results.getMetaData();
3658
3659		assertEquals("Incorrect Column Name 1", "IDX", metadata.getColumnName(1));
3660		assertEquals("Incorrect Column Name 2", "COLUMN2", metadata.getColumnName(2));
3661		assertEquals("Incorrect Column Name 3", "COLUMN3", metadata.getColumnName(3));
3662		assertEquals("Incorrect Column Name 4", "COMMENT", metadata.getColumnName(4));
3663		assertEquals("Incorrect Column Name 5", "COLUMN5", metadata.getColumnName(5));
3664
3665		assertTrue(results.next());
3666		assertEquals("1 is wrong", "178", results.getString(1));
3667		assertEquals("2 is wrong", "AAX", results.getString("COLUMN2"));
3668		assertEquals("3 is wrong", "ED+", results.getString(3));
3669		assertEquals("4 is wrong", "NONE", results.getString(4));
3670		assertEquals("5 is wrong", "T", results.getString("COLUMN5"));
	3881
	3882	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	3883	+ filePath, props);
	3884	Statement stmt = conn.createStatement();
	3885	ResultSet results = stmt.executeQuery("SELECT * FROM defectiveheader"))
	3886	{
	3887	ResultSetMetaData metadata = results.getMetaData();
	3888
	3889	assertEquals("Incorrect Column Name 1", "IDX", metadata.getColumnName(1));
	3890	assertEquals("Incorrect Column Name 2", "COLUMN2", metadata.getColumnName(2));
	3891	assertEquals("Incorrect Column Name 3", "COLUMN3", metadata.getColumnName(3));
	3892	assertEquals("Incorrect Column Name 4", "COMMENT", metadata.getColumnName(4));
	3893	assertEquals("Incorrect Column Name 5", "COLUMN5", metadata.getColumnName(5));
	3894
	3895	assertTrue(results.next());
	3896	assertEquals("1 is wrong", "178", results.getString(1));
	3897	assertEquals("2 is wrong", "AAX", results.getString("COLUMN2"));
	3898	assertEquals("3 is wrong", "ED+", results.getString(3));
	3899	assertEquals("4 is wrong", "NONE", results.getString(4));
	3900	assertEquals("5 is wrong", "T", results.getString("COLUMN5"));
	3901	}
3671	3902	}
3672	3903
3673	3904	@Test

3678	3909	props.put("columnTypes", "Timestamp,Double");
3679	3910	props.put("defectiveHeaders", "True");
3680	3911	props.put("skipLeadingDataLines", "1");
3681
3682		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
3683		+ filePath, props);
3684		Statement stmt = conn.createStatement();
3685		ResultSet results = stmt.executeQuery("SELECT * FROM twoheaders");
3686
3687		assertTrue(results.next());
3688		assertEquals("1 is wrong", "2010-02-21 00:00:00", toUTC.format(results
3689		.getObject(1)));
3690		assertEquals("1 is wrong", "2010-02-21 00:00:00", toUTC.format(results
3691		.getObject("COLUMN1")));
3692		assertEquals("2 is wrong", new Double(21), results.getObject(2));
3693		assertEquals("3 is wrong", new Double(20), results.getObject(3));
3694		assertEquals("4 is wrong", new Double(24), results.getObject(4));
3695
	3912
	3913	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	3914	+ filePath, props);
	3915	Statement stmt = conn.createStatement();
	3916	ResultSet results = stmt.executeQuery("SELECT * FROM twoheaders"))
	3917	{
	3918	assertTrue(results.next());
	3919	assertEquals("1 is wrong", "2010-02-21 00:00:00", toUTC.format(results
	3920	.getObject(1)));
	3921	assertEquals("1 is wrong", "2010-02-21 00:00:00", toUTC.format(results
	3922	.getObject("COLUMN1")));
	3923	assertEquals("2 is wrong", Double.valueOf(21), results.getObject(2));
	3924	assertEquals("3 is wrong", Double.valueOf(20), results.getObject(3));
	3925	assertEquals("4 is wrong", Double.valueOf(24), results.getObject(4));
	3926	}
3696	3927	}
3697	3928
3698	3929	@Test

3708	3939	// Datum,Tijd,Station,P000,P001,P002,P003
3709	3940	props.put("columnTypes", "String,Date,Time,String,Double");
3710	3941
3711		ResultSet results = null;
3712
3713		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
3714		+ filePath, props);
3715		Statement stmt = conn.createStatement();
3716
3717		results = stmt.executeQuery("SELECT * FROM varlen1");
3718		assertTrue(results.next());
3719		assertEquals("007", results.getObject("Station"));
3720		assertEquals(new Double("26.54"), results.getObject("P003"));
3721		assertTrue(results.next());
3722		assertEquals("001", results.getObject("Station"));
3723		assertEquals(new Double("26.55"), results.getObject("P003"));
3724		assertFalse(results.next());
	3942	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	3943	+ filePath, props);
	3944	Statement stmt = conn.createStatement();
	3945	ResultSet results = stmt.executeQuery("SELECT * FROM varlen1"))
	3946	{
	3947	assertTrue(results.next());
	3948	assertEquals("007", results.getObject("Station"));
	3949	assertEquals(Double.valueOf("26.54"), results.getObject("P003"));
	3950	assertTrue(results.next());
	3951	assertEquals("001", results.getObject("Station"));
	3952	assertEquals(Double.valueOf("26.55"), results.getObject("P003"));
	3953	assertFalse(results.next());
	3954	}
3725	3955	}
3726	3956
3727	3957	@Test

3736	3966	props.put("columnNames", "Datum,Tijd,Station,P000,P001,P002,P003,INDEX");
3737	3967	props.put("ignoreNonParseableLines", "True");
3738	3968
3739		ResultSet results = null;
3740
3741		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
3742		+ filePath, props);
3743		Statement stmt = conn.createStatement();
3744
3745		results = stmt.executeQuery("SELECT * FROM varlen");
3746		assertTrue(results.next());
3747		assertEquals("1", results.getObject("index"));
3748		assertEquals("007", results.getObject("Station"));
3749		assertEquals("26.54", results.getObject("P001"));
3750		assertTrue(results.next());
3751		assertEquals("007", results.getObject("Station"));
3752		assertEquals("22.99", results.getObject("P001"));
3753		assertFalse(results.next());
	3969	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	3970	+ filePath, props);
	3971	Statement stmt = conn.createStatement();
	3972	ResultSet results = stmt.executeQuery("SELECT * FROM varlen"))
	3973	{
	3974	assertTrue(results.next());
	3975	assertEquals("1", results.getObject("index"));
	3976	assertEquals("007", results.getObject("Station"));
	3977	assertEquals("26.54", results.getObject("P001"));
	3978	assertTrue(results.next());
	3979	assertEquals("007", results.getObject("Station"));
	3980	assertEquals("22.99", results.getObject("P001"));
	3981	assertFalse(results.next());
	3982	}
3754	3983	}
3755	3984
3756	3985	@Test
3757	3986	public void testWrongColumnCount() throws SQLException
3758	3987	{
3759	3988	Properties props = new Properties();
3760		ResultSet results = null;
3761
3762		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
3763		+ filePath, props);
3764		Statement stmt = conn.createStatement();
3765
3766		results = stmt.executeQuery("SELECT * FROM wrong_column_count");
3767
3768		try
3769		{
3770		while(results.next())
3771		{
3772		}
3773		fail("Should raise a java.sqlSQLException");
3774		}
3775		catch (SQLException e)
3776		{
3777		// Should fail with the line number in message.
3778		assertTrue(e.getMessage().contains(CsvResources.getString("wrongColumnCount")));
3779		assertTrue(e.getMessage().contains("137"));
	3989
	3990	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	3991	+ filePath, props);
	3992	Statement stmt = conn.createStatement();
	3993	ResultSet results = stmt.executeQuery("SELECT * FROM wrong_column_count"))
	3994	{
	3995	try
	3996	{
	3997	while(results.next())
	3998	{
	3999	}
	4000	fail("Should raise a java.sqlSQLException");
	4001	}
	4002	catch (SQLException e)
	4003	{
	4004	// Should fail with the line number in message.
	4005	assertTrue(e.getMessage().contains(CsvResources.getString("wrongColumnCount")));
	4006	assertTrue(e.getMessage().contains("137"));
	4007	}
3780	4008	}
3781	4009	}
3782	4010

3791	4019	// Datum,Tijd,Station,P000,P001,P002,P003
3792	4020	props.put("columnNames", "Datum,Tijd,Station,P000,P001,P002,P003,INDEX");
3793	4021
3794		ResultSet results = null;
3795
3796		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
3797		+ filePath, props);
3798		Statement stmt = conn.createStatement();
3799
3800		results = stmt.executeQuery("SELECT * FROM varlen");
3801		assertTrue(results.next());
3802		assertEquals("1", results.getObject("index"));
3803		assertEquals("007", results.getObject("Station"));
3804		assertEquals("26.54", results.getObject("P001"));
3805		assertTrue(results.next());
3806		assertEquals("007", results.getObject("Station"));
3807		assertEquals("22.99", results.getObject("P001"));
3808		try
3809		{
3810		results.next();
3811		fail("Should raise a java.sqlSQLException");
3812		}
3813		catch (SQLException e)
3814		{
3815		assertTrue(("" + e).contains(CsvResources.getString("wrongColumnCount")));
	4022	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	4023	+ filePath, props);
	4024	Statement stmt = conn.createStatement();
	4025	ResultSet results = stmt.executeQuery("SELECT * FROM varlen"))
	4026	{
	4027	assertTrue(results.next());
	4028	assertEquals("1", results.getObject("index"));
	4029	assertEquals("007", results.getObject("Station"));
	4030	assertEquals("26.54", results.getObject("P001"));
	4031	assertTrue(results.next());
	4032	assertEquals("007", results.getObject("Station"));
	4033	assertEquals("22.99", results.getObject("P001"));
	4034	try
	4035	{
	4036	results.next();
	4037	fail("Should raise a java.sqlSQLException");
	4038	}
	4039	catch (SQLException e)
	4040	{
	4041	assertTrue(("" + e).contains(CsvResources.getString("wrongColumnCount")));
	4042	}
3816	4043	}
3817	4044	}
3818	4045

3832	4059	props.put("locale", Locale.US.toString());
3833	4060	}
3834	4061
3835		ResultSet results = null;
3836
3837		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
3838		+ filePath, props);
3839		Statement stmt = conn.createStatement();
3840
3841		results = stmt.executeQuery("SELECT T FROM yogesh");
3842		assertTrue(results.next());
3843		Timestamp got = results.getTimestamp(1);
3844		assertEquals("2013-11-25 13:29:07", toUTC.format(got));
3845		assertTrue(results.next());
3846		got = results.getTimestamp(1);
3847		assertEquals("2013-12-06 11:52:21", toUTC.format(got));
	4062	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	4063	+ filePath, props);
	4064	Statement stmt = conn.createStatement();
	4065	ResultSet results = stmt.executeQuery("SELECT T FROM yogesh"))
	4066	{
	4067	assertTrue(results.next());
	4068	Timestamp got = results.getTimestamp(1);
	4069	assertEquals("2013-11-25 13:29:07", toUTC.format(got));
	4070	assertTrue(results.next());
	4071	got = results.getTimestamp(1);
	4072	assertEquals("2013-12-06 11:52:21", toUTC.format(got));
	4073	}
3848	4074	}
3849	4075
3850	4076	@Test

3852	4078	{
3853	4079	Properties props = new Properties();
3854	4080	props.put("timeZoneName", "UTC");
3855		props.put("timestampFormat", "dd-MMM-yy hh:mm:ss.SSS aa");
	4081	// A pattern in java.time.format.DateTimeFormatter format
	4082	props.put("timestampFormat", "dd-LLL-yy HH:mm:ss.SSS");
	4083	props.put("useDateTimeFormatter", "true");
3856	4084	props.put("columnTypes", "Int,Timestamp");
3857	4085	props.put("locale", Locale.GERMANY.toString());
3858	4086
3859		ResultSet results = null;
3860
3861		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
3862		+ filePath, props);
3863		Statement stmt = conn.createStatement();
3864
3865		results = stmt.executeQuery("SELECT T FROM yogesh_de");
3866		assertTrue(results.next());
3867		Timestamp got = results.getTimestamp(1);
3868		assertEquals("2013-10-25 13:29:07", toUTC.format(got));
3869		assertTrue(results.next());
3870		got = results.getTimestamp(1);
3871		assertEquals("2013-12-06 11:52:21", toUTC.format(got));
	4087	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	4088	+ filePath, props);
	4089	Statement stmt = conn.createStatement();
	4090	ResultSet results = stmt.executeQuery("SELECT T FROM yogesh_de"))
	4091	{
	4092	assertTrue(results.next());
	4093	Timestamp got = results.getTimestamp(1);
	4094	LocalDateTime gotLocalDateTimeUTC = LocalDateTime.ofInstant(got.toInstant(), ZoneId.of("UTC"));
	4095	// Expect formatted UTC timestamps to be identical to UTC timestamps read from file
	4096	assertEquals("2013-10-25 13:29:07", gotLocalDateTimeUTC.format(toUTCDateTimeFormatter));
	4097	assertTrue(results.next());
	4098	got = results.getTimestamp(1);
	4099	gotLocalDateTimeUTC = LocalDateTime.ofInstant(got.toInstant(), ZoneId.of("UTC"));
	4100	assertEquals("2013-12-06 11:52:21", gotLocalDateTimeUTC.format(toUTCDateTimeFormatter));
	4101	}
3872	4102	}
3873	4103
3874	4104	@Test

3879	4109	props.put("timeZoneName", "Europe/Rome");
3880	4110	props.put("columnTypes", "Int,String,String,Timestamp");
3881	4111
3882		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	4112	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	4113	+ filePath, props);
	4114	Statement stmt = conn.createStatement();
	4115	ResultSet results = stmt
	4116	.executeQuery("SELECT * FROM sample5 WHERE ID=9 OR ID=1"))
	4117	{
	4118	assertTrue(results.next());
	4119	// TODO: getString miserably fails!
	4120	//assertEquals("2001-01-02 12:30:00.0", results.getString("start"));
	4121	Timestamp got = (Timestamp) results.getObject("start");
	4122	assertEquals("2001-01-02 11:30:00", toUTC.format(got));
	4123	got = results.getTimestamp("start");
	4124	assertEquals("2001-01-02 11:30:00", toUTC.format(got));
	4125
	4126	assertTrue(results.next());
	4127	got = results.getTimestamp("start");
	4128	assertEquals("2004-04-02 10:30:00", toUTC.format(got));
	4129
	4130	assertFalse(results.next());
	4131	}
	4132	}
	4133
	4134	@Test
	4135	public void testTimestampInTimeZoneSantiago() throws SQLException,
	4136	ParseException
	4137	{
	4138	Properties props = new Properties();
	4139	props.put("timeZoneName", "America/Santiago");
	4140	props.put("columnTypes", "Int,String,String,Timestamp");
	4141
	4142	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	4143	+ filePath, props);
	4144	Statement stmt = conn.createStatement();
	4145	ResultSet results = stmt
	4146	.executeQuery("SELECT * FROM sample5 WHERE ID=9 OR ID=1"))
	4147	{
	4148	assertTrue(results.next());
	4149	// TODO: getString miserably fails!
	4150	//assertEquals("2001-01-02 12:30:00", results.getString("start"));
	4151	Timestamp got = (Timestamp) results.getObject("start");
	4152	assertEquals("2001-01-02 15:30:00", toUTC.format(got));
	4153	got = results.getTimestamp("start");
	4154	assertEquals("2001-01-02 15:30:00", toUTC.format(got));
	4155
	4156	assertTrue(results.next());
	4157	got = results.getTimestamp("start");
	4158	assertEquals("2004-04-02 16:30:00", toUTC.format(got));
	4159
	4160	assertFalse(results.next());
	4161	}
	4162	}
	4163
	4164	@Test
	4165	public void testTimestampInTimeZoneGMTPlus0400() throws SQLException,
	4166	ParseException
	4167	{
	4168	Properties props = new Properties();
	4169	props.put("timeZoneName", "GMT+04:00");
	4170	props.put("columnTypes", "Int,String,String,Timestamp");
	4171
	4172	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	4173	+ filePath, props);
	4174	Statement stmt = conn.createStatement();
	4175	ResultSet results = stmt
	4176	.executeQuery("SELECT * FROM sample5 WHERE ID=9 OR ID=1"))
	4177	{
	4178	assertTrue(results.next());
	4179	// TODO: getString miserably fails!
	4180	// assertEquals("2001-01-02 12:30:00", results.getString("start"));
	4181	Timestamp got = (Timestamp) results.getObject("start");
	4182	assertEquals("2001-01-02 08:30:00", toUTC.format(got));
	4183	got = results.getTimestamp("start");
	4184	assertEquals("2001-01-02 08:30:00", toUTC.format(got));
	4185
	4186	assertTrue(results.next());
	4187	got = results.getTimestamp("start");
	4188	assertEquals("2004-04-02 08:30:00", toUTC.format(got));
	4189
	4190	assertFalse(results.next());
	4191	}
	4192	}
	4193
	4194	@Test
	4195	public void testTimestampInTimeZoneGMTMinus0400() throws SQLException,
	4196	ParseException
	4197	{
	4198	Properties props = new Properties();
	4199	props.put("timeZoneName", "GMT-04:00");
	4200	props.put("columnTypes", "Int,String,String,Timestamp");
	4201
	4202	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	4203	+ filePath, props);
	4204	Statement stmt = conn.createStatement();
	4205	ResultSet results = stmt
	4206	.executeQuery("SELECT * FROM sample5 WHERE ID=9 OR ID=1"))
	4207	{
	4208	assertTrue(results.next());
	4209	// TODO: getString miserably fails!
	4210	// assertEquals("2001-01-02 12:30:00", results.getString("start"));
	4211	Timestamp got = (Timestamp) results.getObject("start");
	4212	assertEquals("2001-01-02 16:30:00", toUTC.format(got));
	4213	got = results.getTimestamp("start");
	4214	assertEquals("2001-01-02 16:30:00", toUTC.format(got));
	4215
	4216	assertTrue(results.next());
	4217	got = results.getTimestamp("start");
	4218	assertEquals("2004-04-02 16:30:00", toUTC.format(got));
	4219
	4220	assertFalse(results.next());
	4221	}
	4222	}
	4223
	4224	@Test
	4225	public void testAddingDateToTimeInTimeZoneAthens() throws SQLException,
	4226	ParseException
	4227	{
	4228	Properties props = new Properties();
	4229	props.put("timeZoneName", "Europe/Athens");
	4230	props.put("columnTypes", "Int,String,Date,Time");
	4231
	4232	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
3883	4233	+ filePath, props);
3884	4234	Statement stmt = conn.createStatement();
3885	4235	ResultSet results = stmt
3886		.executeQuery("SELECT * FROM sample5 WHERE ID=9 OR ID=1");
3887
3888		assertTrue(results.next());
3889		// TODO: getString miserably fails!
3890		//assertEquals("2001-01-02 12:30:00.0", results.getString("start"));
3891		Timestamp got = (Timestamp) results.getObject("start");
3892		assertEquals("2001-01-02 11:30:00", toUTC.format(got));
3893		got = results.getTimestamp("start");
3894		assertEquals("2001-01-02 11:30:00", toUTC.format(got));
3895
3896		assertTrue(results.next());
3897		got = results.getTimestamp("start");
3898		assertEquals("2004-04-02 10:30:00", toUTC.format(got));
3899
3900		assertFalse(results.next());
3901		}
3902
3903		@Test
3904		public void testTimestampInTimeZoneSantiago() throws SQLException,
3905		ParseException
3906		{
3907		Properties props = new Properties();
3908		props.put("timeZoneName", "America/Santiago");
3909		props.put("columnTypes", "Int,String,String,Timestamp");
3910
3911		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
3912		+ filePath, props);
3913		Statement stmt = conn.createStatement();
3914		ResultSet results = stmt
3915		.executeQuery("SELECT * FROM sample5 WHERE ID=9 OR ID=1");
3916
3917		assertTrue(results.next());
3918		// TODO: getString miserably fails!
3919		//assertEquals("2001-01-02 12:30:00", results.getString("start"));
3920		Timestamp got = (Timestamp) results.getObject("start");
3921		assertEquals("2001-01-02 15:30:00", toUTC.format(got));
3922		got = results.getTimestamp("start");
3923		assertEquals("2001-01-02 15:30:00", toUTC.format(got));
3924
3925		assertTrue(results.next());
3926		got = results.getTimestamp("start");
3927		assertEquals("2004-04-02 16:30:00", toUTC.format(got));
3928
3929		assertFalse(results.next());
3930		}
3931
3932		@Test
3933		public void testTimestampInTimeZoneGMTPlus0400() throws SQLException,
3934		ParseException
3935		{
3936		Properties props = new Properties();
3937		props.put("timeZoneName", "GMT+04:00");
3938		props.put("columnTypes", "Int,String,String,Timestamp");
3939
3940		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
3941		+ filePath, props);
3942		Statement stmt = conn.createStatement();
3943		ResultSet results = stmt
3944		.executeQuery("SELECT * FROM sample5 WHERE ID=9 OR ID=1");
3945
3946		assertTrue(results.next());
3947		// TODO: getString miserably fails!
3948		// assertEquals("2001-01-02 12:30:00", results.getString("start"));
3949		Timestamp got = (Timestamp) results.getObject("start");
3950		assertEquals("2001-01-02 08:30:00", toUTC.format(got));
3951		got = results.getTimestamp("start");
3952		assertEquals("2001-01-02 08:30:00", toUTC.format(got));
3953
3954		assertTrue(results.next());
3955		got = results.getTimestamp("start");
3956		assertEquals("2004-04-02 08:30:00", toUTC.format(got));
3957
3958		assertFalse(results.next());
3959		}
3960
3961		@Test
3962		public void testTimestampInTimeZoneGMTMinus0400() throws SQLException,
3963		ParseException
3964		{
3965		Properties props = new Properties();
3966		props.put("timeZoneName", "GMT-04:00");
3967		props.put("columnTypes", "Int,String,String,Timestamp");
3968
3969		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
3970		+ filePath, props);
3971		Statement stmt = conn.createStatement();
3972		ResultSet results = stmt
3973		.executeQuery("SELECT * FROM sample5 WHERE ID=9 OR ID=1");
3974
3975		assertTrue(results.next());
3976		// TODO: getString miserably fails!
3977		// assertEquals("2001-01-02 12:30:00", results.getString("start"));
3978		Timestamp got = (Timestamp) results.getObject("start");
3979		assertEquals("2001-01-02 16:30:00", toUTC.format(got));
3980		got = results.getTimestamp("start");
3981		assertEquals("2001-01-02 16:30:00", toUTC.format(got));
3982
3983		assertTrue(results.next());
3984		got = results.getTimestamp("start");
3985		assertEquals("2004-04-02 16:30:00", toUTC.format(got));
3986
3987		assertFalse(results.next());
3988		}
3989
3990		@Test
3991		public void testAddingDateToTimeInTimeZoneAthens() throws SQLException,
3992		ParseException
3993		{
3994		Properties props = new Properties();
3995		props.put("timeZoneName", "Europe/Athens");
3996		props.put("columnTypes", "Int,String,Date,Time");
3997
3998		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
3999		+ filePath, props);
4000		Statement stmt = conn.createStatement();
4001		ResultSet results = stmt
4002		.executeQuery("SELECT ID, NAME, D + T as DT FROM sample8");
4003
4004		assertTrue(results.next());
4005		// TODO: getString miserably fails!
4006		//assertEquals("2001-01-02 12:30:00", results.getString("start"));
4007		Timestamp got = (Timestamp) results.getObject("DT");
4008		assertEquals("2010-01-01 23:30:00", toUTC.format(got));
4009
4010		assertTrue(results.next());
4011		got = (Timestamp) results.getObject("DT");
4012		assertEquals("2010-02-01 23:30:00", toUTC.format(got));
4013
4014		assertTrue(results.next());
4015		got = (Timestamp) results.getObject("DT");
4016		assertEquals("2010-03-27 23:30:00", toUTC.format(got));
4017
4018		assertTrue(results.next());
4019		got = (Timestamp) results.getObject("DT");
4020		assertEquals("2010-03-28 02:30:00", toUTC.format(got));
4021
4022		assertTrue(results.next());
4023		got = (Timestamp) results.getObject("DT");
4024		assertEquals("2009-10-24 22:30:00", toUTC.format(got));
4025
4026		assertTrue(results.next());
4027		got = (Timestamp) results.getObject("DT");
4028		assertEquals("2009-10-25 03:30:00", toUTC.format(got));
4029
4030		assertFalse(results.next());
	4236	.executeQuery("SELECT ID, NAME, D + T as DT FROM sample8"))
	4237	{
	4238	assertTrue(results.next());
	4239	// TODO: getString miserably fails!
	4240	//assertEquals("2001-01-02 12:30:00", results.getString("start"));
	4241	Timestamp got = (Timestamp) results.getObject("DT");
	4242	assertEquals("2010-01-01 23:30:00", toUTC.format(got));
	4243
	4244	assertTrue(results.next());
	4245	got = (Timestamp) results.getObject("DT");
	4246	assertEquals("2010-02-01 23:30:00", toUTC.format(got));
	4247
	4248	assertTrue(results.next());
	4249	got = (Timestamp) results.getObject("DT");
	4250	assertEquals("2010-03-27 23:30:00", toUTC.format(got));
	4251
	4252	assertTrue(results.next());
	4253	got = (Timestamp) results.getObject("DT");
	4254	assertEquals("2010-03-28 02:30:00", toUTC.format(got));
	4255
	4256	assertTrue(results.next());
	4257	got = (Timestamp) results.getObject("DT");
	4258	assertEquals("2009-10-24 22:30:00", toUTC.format(got));
	4259
	4260	assertTrue(results.next());
	4261	got = (Timestamp) results.getObject("DT");
	4262	assertEquals("2009-10-25 03:30:00", toUTC.format(got));
	4263
	4264	assertFalse(results.next());
	4265	}
4031	4266	}
4032	4267
4033	4268	@Test

4038	4273	props.put("timeZoneName", "GMT-05:00");
4039	4274	props.put("columnTypes", "Int,String,Date,Time");
4040	4275
4041		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
4042		+ filePath, props);
4043		Statement stmt = conn.createStatement();
4044		ResultSet results = stmt
4045		.executeQuery("SELECT ID, NAME, D + T as DT FROM sample8");
4046
4047		assertTrue(results.next());
4048		// TODO: getString miserably fails!
4049		//assertEquals("2001-01-02 12:30:00", results.getString("start"));
4050		Timestamp got = (Timestamp) results.getObject("DT");
4051		assertEquals("2010-01-02 06:30:00", toUTC.format(got));
4052
4053		assertTrue(results.next());
4054		got = (Timestamp) results.getObject("DT");
4055		assertEquals("2010-02-02 06:30:00", toUTC.format(got));
4056
4057		assertTrue(results.next());
4058		got = (Timestamp) results.getObject("DT");
4059		assertEquals("2010-03-28 06:30:00", toUTC.format(got));
4060
4061		assertTrue(results.next());
4062		got = (Timestamp) results.getObject("DT");
4063		assertEquals("2010-03-28 10:30:00", toUTC.format(got));
4064
4065		assertTrue(results.next());
4066		got = (Timestamp) results.getObject("DT");
4067		assertEquals("2009-10-25 06:30:00", toUTC.format(got));
4068
4069		assertTrue(results.next());
4070		got = (Timestamp) results.getObject("DT");
4071		assertEquals("2009-10-25 10:30:00", toUTC.format(got));
4072
4073		assertFalse(results.next());
	4276	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	4277	+ filePath, props);
	4278	Statement stmt = conn.createStatement();
	4279	ResultSet results = stmt
	4280	.executeQuery("SELECT ID, NAME, D + T as DT FROM sample8"))
	4281	{
	4282	assertTrue(results.next());
	4283	// TODO: getString miserably fails!
	4284	//assertEquals("2001-01-02 12:30:00", results.getString("start"));
	4285	Timestamp got = (Timestamp) results.getObject("DT");
	4286	assertEquals("2010-01-02 06:30:00", toUTC.format(got));
	4287
	4288	assertTrue(results.next());
	4289	got = (Timestamp) results.getObject("DT");
	4290	assertEquals("2010-02-02 06:30:00", toUTC.format(got));
	4291
	4292	assertTrue(results.next());
	4293	got = (Timestamp) results.getObject("DT");
	4294	assertEquals("2010-03-28 06:30:00", toUTC.format(got));
	4295
	4296	assertTrue(results.next());
	4297	got = (Timestamp) results.getObject("DT");
	4298	assertEquals("2010-03-28 10:30:00", toUTC.format(got));
	4299
	4300	assertTrue(results.next());
	4301	got = (Timestamp) results.getObject("DT");
	4302	assertEquals("2009-10-25 06:30:00", toUTC.format(got));
	4303
	4304	assertTrue(results.next());
	4305	got = (Timestamp) results.getObject("DT");
	4306	assertEquals("2009-10-25 10:30:00", toUTC.format(got));
	4307
	4308	assertFalse(results.next());
	4309	}
4074	4310	}
4075	4311
4076	4312	@Test

4081	4317	props.put("quotechar", "'");
4082	4318	props.put("fileExtension", ".txt");
4083	4319
4084		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
4085		+ filePath, props);
4086
4087		Statement stmt = conn.createStatement();
4088
4089		ResultSet results = stmt.executeQuery("SELECT * FROM uses_quotes");
4090		assertTrue(results.next());
4091		assertEquals("uno", results.getObject("COLUMN2"));
4092		assertTrue(results.next());
4093		assertEquals("a 'quote' (source unknown)", results.getObject("COLUMN2"));
4094		assertTrue(results.next());
4095		assertEquals("another \"quote\" (also unkown)", results.getObject("COLUMN2"));
4096		assertTrue(results.next());
4097		assertEquals("a 'quote\" that gives error", results.getObject("COLUMN2"));
4098		assertTrue(results.next());
4099		assertEquals("another not parsable \"quote'", results.getObject("COLUMN2"));
4100		assertTrue(results.next());
4101		assertEquals("collecting quotes \"\"''", results.getObject("COLUMN2"));
4102		assertFalse(results.next());
	4320	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	4321	+ filePath, props);
	4322
	4323	Statement stmt = conn.createStatement();
	4324
	4325	ResultSet results = stmt.executeQuery("SELECT * FROM uses_quotes"))
	4326	{
	4327	assertTrue(results.next());
	4328	assertEquals("uno", results.getObject("COLUMN2"));
	4329	assertTrue(results.next());
	4330	assertEquals("a 'quote' (source unknown)", results.getObject("COLUMN2"));
	4331	assertTrue(results.next());
	4332	assertEquals("another \"quote\" (also unkown)", results.getObject("COLUMN2"));
	4333	assertTrue(results.next());
	4334	assertEquals("a 'quote\" that gives error", results.getObject("COLUMN2"));
	4335	assertTrue(results.next());
	4336	assertEquals("another not parsable \"quote'", results.getObject("COLUMN2"));
	4337	assertTrue(results.next());
	4338	assertEquals("collecting quotes \"\"''", results.getObject("COLUMN2"));
	4339	assertFalse(results.next());
	4340	}
4103	4341	}
4104	4342
4105	4343	@Test

4110	4348	props.put("separator", ";");
4111	4349	props.put("columnTypes", "String,String,Double");
4112	4350
4113		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
4114		+ filePath, props);
4115
4116		Statement stmt = conn.createStatement();
4117
4118		ResultSet results = stmt
4119		.executeQuery("SELECT NAME,ID,EXTRA_FIELD FROM sample");
4120		assertTrue(results.next());
4121		assertTrue(results.next());
4122		assertTrue(results.next());
4123		assertTrue(results.next());
4124		assertTrue(results.next());
4125		assertTrue(results.next());
4126		assertTrue(results.next()); // Mackie Messer
4127		assertEquals(new Double(34.1), results.getObject(3));
4128		assertTrue(results.next()); // Polly Peachum
4129		assertEquals(new Double(30.5), results.getObject(3));
	4351	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	4352	+ filePath, props);
	4353
	4354	Statement stmt = conn.createStatement();
	4355
	4356	ResultSet results = stmt
	4357	.executeQuery("SELECT NAME,ID,EXTRA_FIELD FROM sample"))
	4358	{
	4359	assertTrue(results.next());
	4360	assertTrue(results.next());
	4361	assertTrue(results.next());
	4362	assertTrue(results.next());
	4363	assertTrue(results.next());
	4364	assertTrue(results.next());
	4365	assertTrue(results.next()); // Mackie Messer
	4366	assertEquals(Double.valueOf(34.1), results.getObject(3));
	4367	assertTrue(results.next()); // Polly Peachum
	4368	assertEquals(Double.valueOf(30.5), results.getObject(3));
	4369	}
4130	4370	}
4131	4371
4132	4372	@Test
4133	4373	public void testLiteral() throws SQLException
4134	4374	{
4135		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	4375	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
4136	4376	+ filePath);
4137	4377
4138		Statement stmt = conn.createStatement();
4139
4140		ResultSet results = stmt
4141		.executeQuery("SELECT name, id, 'Bananas' as t FROM sample");
4142
4143		results.next();
4144		assertEquals("Incorrect ID Value", "Q123", results.getString("ID"));
4145		assertEquals("Incorrect ID Value", "Bananas", results.getString("T"));
4146		assertEquals("Incorrect ID Value", "Bananas", results.getString("t"));
4147		results.next();
4148		assertEquals("Incorrect ID Value", "Bananas", results.getString("T"));
4149		results.next();
4150		assertEquals("Incorrect ID Value", "Bananas", results.getString("T"));
4151		results.next();
4152		assertEquals("Incorrect ID Value", "Bananas", results.getString("T"));
	4378	Statement stmt = conn.createStatement();
	4379
	4380	ResultSet results = stmt
	4381	.executeQuery("SELECT name, id, 'Bananas' as t FROM sample"))
	4382	{
	4383	results.next();
	4384	assertEquals("Incorrect ID Value", "Q123", results.getString("ID"));
	4385	assertEquals("Incorrect ID Value", "Bananas", results.getString("T"));
	4386	assertEquals("Incorrect ID Value", "Bananas", results.getString("t"));
	4387	results.next();
	4388	assertEquals("Incorrect ID Value", "Bananas", results.getString("T"));
	4389	results.next();
	4390	assertEquals("Incorrect ID Value", "Bananas", results.getString("T"));
	4391	results.next();
	4392	assertEquals("Incorrect ID Value", "Bananas", results.getString("T"));
	4393	}
4153	4394	}
4154	4395
4155	4396	@Test
4156	4397	public void testTableNameAsAlias() throws SQLException
4157	4398	{
4158		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	4399	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
4159	4400	+ filePath);
4160	4401
4161		Statement stmt = conn.createStatement();
4162
4163		ResultSet results = stmt.executeQuery("SELECT sample.id FROM sample");
4164
4165		results.next();
4166		assertEquals("Incorrect ID Value", "Q123", results.getString("ID"));
	4402	Statement stmt = conn.createStatement();
	4403
	4404	ResultSet results = stmt.executeQuery("SELECT sample.id FROM sample"))
	4405	{
	4406	results.next();
	4407	assertEquals("Incorrect ID Value", "Q123", results.getString("ID"));
	4408	}
4167	4409	}
4168	4410
4169	4411	@Test
4170	4412	public void testTableAlias() throws SQLException
4171	4413	{
4172		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	4414	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
4173	4415	+ filePath);
4174	4416
4175		Statement stmt = conn.createStatement();
4176
4177		ResultSet results = stmt
4178		.executeQuery("SELECT S.id, s.Extra_field FROM sample S");
4179
4180		results.next();
4181		assertEquals("Incorrect ID Value", "Q123", results.getString("ID"));
4182		assertEquals("Incorrect ID Value", "F", results.getString("EXTRA_FIELD"));
4183		assertEquals("Incorrect ID Value", "Q123", results.getString(1));
4184		assertEquals("Incorrect ID Value", "F", results.getString(2));
	4417	Statement stmt = conn.createStatement();
	4418
	4419	ResultSet results = stmt
	4420	.executeQuery("SELECT S.id, s.Extra_field FROM sample S"))
	4421	{
	4422	results.next();
	4423	assertEquals("Incorrect ID Value", "Q123", results.getString("ID"));
	4424	assertEquals("Incorrect ID Value", "F", results.getString("EXTRA_FIELD"));
	4425	assertEquals("Incorrect ID Value", "Q123", results.getString(1));
	4426	assertEquals("Incorrect ID Value", "F", results.getString(2));
	4427	}
4185	4428	}
4186	4429
4187	4430	@Test
4188	4431	public void testTableAliasWithWhere() throws SQLException
4189	4432	{
4190		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	4433	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
4191	4434	+ filePath);
4192	4435
4193		Statement stmt = conn.createStatement();
4194
4195		ResultSet results = stmt
4196		.executeQuery("SELECT * FROM sample AS S where S.ID='A123'");
4197
4198		results.next();
4199		assertEquals("Incorrect ID Value", "A123", results.getString("ID"));
4200		assertEquals("Incorrect ID Value", "A", results.getString("EXTRA_FIELD"));
4201		assertEquals("Incorrect ID Value", "A123", results.getString(1));
4202		assertEquals("Incorrect ID Value", "A", results.getString(3));
4203		assertFalse(results.next());
	4436	Statement stmt = conn.createStatement();
	4437
	4438	ResultSet results = stmt
	4439	.executeQuery("SELECT * FROM sample AS S where S.ID='A123'"))
	4440	{
	4441	results.next();
	4442	assertEquals("Incorrect ID Value", "A123", results.getString("ID"));
	4443	assertEquals("Incorrect ID Value", "A", results.getString("EXTRA_FIELD"));
	4444	assertEquals("Incorrect ID Value", "A123", results.getString(1));
	4445	assertEquals("Incorrect ID Value", "A", results.getString(3));
	4446	assertFalse(results.next());
	4447	}
4204	4448	}
4205	4449
4206	4450	@Test
4207	4451	public void testMaxRows() throws SQLException
4208	4452	{
4209		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	4453	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
4210	4454	+ filePath);
4211	4455
4212		Statement stmt = conn.createStatement();
4213		stmt.setMaxRows(4);
4214		assertEquals("getMaxRows() incorrect", 4, stmt.getMaxRows());
4215
4216		ResultSet results = stmt.executeQuery("SELECT * FROM sample5");
4217		// The maxRows value at the time of the query should be used, not the value below.
4218		stmt.setMaxRows(7);
4219
4220		assertTrue("Reading row 1 failed", results.next());
4221		assertTrue("Reading row 2 failed", results.next());
4222		assertTrue("Reading row 3 failed", results.next());
4223		assertTrue("Reading row 4 failed", results.next());
4224		assertFalse("Stopping after row 4 failed", results.next());
	4456	Statement stmt = conn.createStatement())
	4457	{
	4458	stmt.setMaxRows(4);
	4459	assertEquals("getMaxRows() incorrect", 4, stmt.getMaxRows());
	4460
	4461	ResultSet results = stmt.executeQuery("SELECT * FROM sample5");
	4462	// The maxRows value at the time of the query should be used, not the value below.
	4463	stmt.setMaxRows(7);
	4464
	4465	assertTrue("Reading row 1 failed", results.next());
	4466	assertTrue("Reading row 2 failed", results.next());
	4467	assertTrue("Reading row 3 failed", results.next());
	4468	assertTrue("Reading row 4 failed", results.next());
	4469	assertFalse("Stopping after row 4 failed", results.next());
	4470	}
4225	4471	}
4226	4472
4227	4473	@Test
4228	4474	public void testFetchSize() throws SQLException
4229	4475	{
4230		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	4476	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
4231	4477	+ filePath);
4232	4478
4233		Statement stmt = conn.createStatement();
4234		stmt.setFetchSize(50);
4235		assertEquals("getFetchSize() incorrect", 50, stmt.getFetchSize());
4236
4237		ResultSet results = stmt.executeQuery("SELECT * FROM sample5");
4238		assertEquals("getFetchSize() incorrect", 50, results.getFetchSize());
4239		results.setFetchSize(20);
4240		assertEquals("getFetchSize() incorrect", 20, results.getFetchSize());
	4479	Statement stmt = conn.createStatement())
	4480	{
	4481	stmt.setFetchSize(50);
	4482	assertEquals("getFetchSize() incorrect", 50, stmt.getFetchSize());
	4483
	4484	ResultSet results = stmt.executeQuery("SELECT * FROM sample5");
	4485	assertEquals("getFetchSize() incorrect", 50, results.getFetchSize());
	4486	results.setFetchSize(20);
	4487	assertEquals("getFetchSize() incorrect", 20, results.getFetchSize());
	4488	}
4241	4489	}
4242	4490
4243	4491	@Test
4244	4492	public void testFetchDirection() throws SQLException
4245	4493	{
4246		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	4494	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
4247	4495	+ filePath);
4248	4496
4249		Statement stmt = conn.createStatement();
4250		stmt.setFetchDirection(ResultSet.FETCH_UNKNOWN);
4251		assertEquals("getFetchDirection() incorrect", ResultSet.FETCH_UNKNOWN, stmt.getFetchDirection());
4252
4253		ResultSet results = stmt.executeQuery("SELECT * FROM sample5");
4254		assertEquals("getFetchDirection() incorrect", ResultSet.FETCH_UNKNOWN, results.getFetchDirection());
4255		results.setFetchDirection(ResultSet.FETCH_FORWARD);
4256		assertEquals("getFetchDirection() incorrect", ResultSet.FETCH_FORWARD, results.getFetchDirection());
	4497	Statement stmt = conn.createStatement())
	4498	{
	4499	stmt.setFetchDirection(ResultSet.FETCH_UNKNOWN);
	4500	assertEquals("getFetchDirection() incorrect", ResultSet.FETCH_UNKNOWN, stmt.getFetchDirection());
	4501
	4502	try (ResultSet results = stmt.executeQuery("SELECT * FROM sample5"))
	4503	{
	4504	assertEquals("getFetchDirection() incorrect", ResultSet.FETCH_UNKNOWN, results.getFetchDirection());
	4505	results.setFetchDirection(ResultSet.FETCH_FORWARD);
	4506	assertEquals("getFetchDirection() incorrect", ResultSet.FETCH_FORWARD, results.getFetchDirection());
	4507	}
	4508	}
4257	4509	}
4258	4510
4259	4511	@Test
4260	4512	public void testResultSet() throws SQLException
4261	4513	{
4262		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	4514	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
4263	4515	+ filePath);
4264	4516
4265		Statement stmt = conn.createStatement();
4266		// No query executed yet.
4267		assertNull(stmt.getResultSet());
4268		assertFalse(stmt.getMoreResults());
4269		assertEquals("Update count wrong", -1, stmt.getUpdateCount());
4270
4271		ResultSet results1 = stmt.executeQuery("SELECT * FROM sample5");
4272		ResultSet results2 = stmt.getResultSet();
4273		assertEquals("Result sets not equal", results1, results2);
4274		assertEquals("Update count wrong", -1, stmt.getUpdateCount());
4275		assertFalse(stmt.getMoreResults());
4276		assertNull("Result set not null", stmt.getResultSet());
4277		assertTrue("Result set was not closed", results1.isClosed());
	4517	Statement stmt = conn.createStatement())
	4518	{
	4519	// No query executed yet.
	4520	assertNull(stmt.getResultSet());
	4521	assertFalse(stmt.getMoreResults());
	4522	assertEquals("Update count wrong", -1, stmt.getUpdateCount());
	4523
	4524	ResultSet results1 = stmt.executeQuery("SELECT * FROM sample5");
	4525	ResultSet results2 = stmt.getResultSet();
	4526	assertEquals("Result sets not equal", results1, results2);
	4527	assertEquals("Update count wrong", -1, stmt.getUpdateCount());
	4528	assertFalse(stmt.getMoreResults());
	4529	assertNull("Result set not null", stmt.getResultSet());
	4530	assertTrue("Result set was not closed", results1.isClosed());
	4531	}
4278	4532	}
4279	4533
4280	4534	@Test
4281	4535	public void testResultSetClosed() throws SQLException
4282	4536	{
4283		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	4537	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
4284	4538	+ filePath);
4285	4539
4286		Statement stmt = conn.createStatement();
4287
4288		ResultSet results1 = stmt.executeQuery("SELECT * FROM sample5");
4289		ResultSet results2 = stmt.executeQuery("SELECT * FROM sample");
4290		assertTrue("First result set is not closed", results1.isClosed());
4291		assertFalse("Second result set is closed", results2.isClosed());
4292		try
4293		{
4294		results1.next();
4295		fail("Closed result set should throw SQLException");
4296		}
4297		catch (SQLException e)
4298		{
4299		assertEquals("java.sql.SQLException: " + CsvResources.getString("closedResultSet"), "" + e);
	4540	Statement stmt = conn.createStatement();
	4541	ResultSet results1 = stmt.executeQuery("SELECT * FROM sample5");
	4542	ResultSet results2 = stmt.executeQuery("SELECT * FROM sample"))
	4543	{
	4544	assertTrue("First result set is not closed", results1.isClosed());
	4545	assertFalse("Second result set is closed", results2.isClosed());
	4546	try
	4547	{
	4548	results1.next();
	4549	fail("Closed result set should throw SQLException");
	4550	}
	4551	catch (SQLException e)
	4552	{
	4553	assertEquals("java.sql.SQLException: " + CsvResources.getString("closedResultSet"), "" + e);
	4554	}
4300	4555	}
4301	4556	}
4302	4557
4303	4558	@Test
4304	4559	public void testResultSetGetFromClosed() throws SQLException
4305	4560	{
4306		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	4561	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
4307	4562	+ filePath);
4308	4563
4309		Statement stmt = conn.createStatement();
4310
4311		ResultSet results = stmt.executeQuery("SELECT ID FROM sample");
4312		assertTrue(results.next());
4313		assertEquals("Incorrect ID Value", "Q123", results.getString("ID"));
4314		results.close();
4315		try
4316		{
4317		results.getString("ID");
4318		fail("Closed result set should throw SQLException");
4319		}
4320		catch (SQLException e)
4321		{
4322		assertEquals("java.sql.SQLException: " + CsvResources.getString("closedResultSet"), "" + e);
	4564	Statement stmt = conn.createStatement();
	4565
	4566	ResultSet results = stmt.executeQuery("SELECT ID FROM sample"))
	4567	{
	4568	assertTrue(results.next());
	4569	assertEquals("Incorrect ID Value", "Q123", results.getString("ID"));
	4570	results.close();
	4571	try
	4572	{
	4573	results.getString("ID");
	4574	fail("Closed result set should throw SQLException");
	4575	}
	4576	catch (SQLException e)
	4577	{
	4578	assertEquals("java.sql.SQLException: " + CsvResources.getString("closedResultSet"), "" + e);
	4579	}
4323	4580	}
4324	4581	}
4325	4582

4327	4584	public void testHeaderlineWithMultipleTables() throws SQLException
4328	4585	{
4329	4586	Properties props = new Properties();
4330		// Define different headerline values for table banks and table transactions.
	4587	// Define different headerline values for table banks and table transactions.
4331	4588	props.put("headerline.banks", "BLZ,BANK_NAME");
4332	4589	props.put("headerline.transactions", "TRANS_DATE,FROM_ACCT,FROM_BLZ,TO_ACCT,TO_BLZ,AMOUNT");
4333	4590	props.put("suppressHeaders", "true");
4334	4591	props.put("fileExtension", ".txt");
4335	4592	props.put("commentChar", "#");
4336		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
4337		+ filePath, props);
4338		Statement stmt = conn.createStatement();
4339		ResultSet results = stmt.executeQuery("SELECT * FROM banks where BANK_NAME like 'Sparkasse%'");
4340
4341		// Check that column names from headerline are used for table banks.
4342		assertEquals("BLZ wrong", "BLZ", results.getMetaData().getColumnName(1));
4343		assertEquals("BANK_NAME wrong", "BANK_NAME", results.getMetaData().getColumnName(2));
4344		assertFalse(results.next());
4345		results.close();
4346		results = stmt.executeQuery("SELECT * FROM transactions");
4347		assertTrue(results.next());
4348
4349		// Check that column names for table transactions are correct too.
4350		assertEquals("TRANS_DATE wrong", "19-10-2011", results.getString("TRANS_DATE"));
4351		assertEquals("FROM_ACCT wrong", "3670345", results.getString("FROM_ACCT"));
4352		assertEquals("AMOUNT wrong", "250.00", results.getString("AMOUNT"));
	4593
	4594	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	4595	+ filePath, props);
	4596	Statement stmt = conn.createStatement())
	4597	{
	4598	try (ResultSet results = stmt.executeQuery("SELECT * FROM banks where BANK_NAME like 'Sparkasse%'"))
	4599	{
	4600	// Check that column names from headerline are used for table banks.
	4601	assertEquals("BLZ wrong", "BLZ", results.getMetaData().getColumnName(1));
	4602	assertEquals("BANK_NAME wrong", "BANK_NAME", results.getMetaData().getColumnName(2));
	4603	assertFalse(results.next());
	4604	}
	4605
	4606	try (ResultSet results = stmt.executeQuery("SELECT * FROM transactions"))
	4607	{
	4608	assertTrue(results.next());
	4609
	4610	// Check that column names for table transactions are correct too.
	4611	assertEquals("TRANS_DATE wrong", "19-10-2011", results.getString("TRANS_DATE"));
	4612	assertEquals("FROM_ACCT wrong", "3670345", results.getString("FROM_ACCT"));
	4613	assertEquals("AMOUNT wrong", "250.00", results.getString("AMOUNT"));
	4614	}
	4615	}
4353	4616	}
4354	4617
4355	4618	@Test
4356	4619	public void testWarnings() throws SQLException
4357	4620	{
4358		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	4621	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
4359	4622	+ filePath);
4360	4623
4361		Statement stmt = conn.createStatement();
4362
4363		ResultSet results = stmt.executeQuery("SELECT * FROM sample");
4364		assertTrue(results.next());
4365		assertNull("Warnings should be null", results.getWarnings());
4366		results.clearWarnings();
4367		assertNull("Warnings should still be null", results.getWarnings());
	4624	Statement stmt = conn.createStatement();
	4625
	4626	ResultSet results = stmt.executeQuery("SELECT * FROM sample"))
	4627	{
	4628	assertTrue(results.next());
	4629	assertNull("Warnings should be null", results.getWarnings());
	4630	results.clearWarnings();
	4631	assertNull("Warnings should still be null", results.getWarnings());
	4632	}
4368	4633	}
4369	4634
4370	4635	@Test
4371	4636	public void testStringWasNull() throws SQLException
4372	4637	{
4373		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	4638	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
4374	4639	+ filePath);
4375	4640
4376		Statement stmt = conn.createStatement();
4377
4378		ResultSet results = stmt.executeQuery("SELECT ID FROM sample");
4379		assertTrue(results.next());
4380		assertEquals("ID wrong", "Q123", results.getString(1));
4381		assertFalse(results.wasNull());
	4641	Statement stmt = conn.createStatement();
	4642
	4643	ResultSet results = stmt.executeQuery("SELECT ID FROM sample"))
	4644	{
	4645	assertTrue(results.next());
	4646	assertEquals("ID wrong", "Q123", results.getString(1));
	4647	assertFalse(results.wasNull());
	4648	}
4382	4649	}
4383	4650
4384	4651	@Test
4385	4652	public void testObjectWasNull() throws SQLException
4386	4653	{
4387		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	4654	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
4388	4655	+ filePath);
4389	4656
4390		Statement stmt = conn.createStatement();
4391
4392		ResultSet results = stmt.executeQuery("SELECT ID FROM sample");
4393		assertTrue(results.next());
4394		assertEquals("ID wrong", "Q123", results.getObject(1));
4395		assertFalse(results.wasNull());
	4657	Statement stmt = conn.createStatement();
	4658
	4659	ResultSet results = stmt.executeQuery("SELECT ID FROM sample"))
	4660	{
	4661	assertTrue(results.next());
	4662	assertEquals("ID wrong", "Q123", results.getObject(1));
	4663	assertFalse(results.wasNull());
	4664	}
4396	4665	}
4397	4666
4398	4667	@Test
4399	4668	public void testTableReader() throws SQLException
4400	4669	{
4401		Connection conn = DriverManager.getConnection("jdbc:relique:csv:class:" +
	4670	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:class:" +
4402	4671	TableReaderTester.class.getName());
4403		Statement stmt = conn.createStatement();
4404		ResultSet results = stmt.executeQuery("SELECT * FROM airline where code='BA'");
4405		assertTrue(results.next());
4406		assertEquals("NAME wrong", "British Airways", results.getString("NAME"));
	4672	Statement stmt = conn.createStatement();
	4673	ResultSet results = stmt.executeQuery("SELECT * FROM airline where code='BA'"))
	4674	{
	4675	assertTrue(results.next());
	4676	assertEquals("NAME wrong", "British Airways", results.getString("NAME"));
	4677	}
4407	4678	}
4408	4679
4409	4680	@Test
4410	4681	public void testTableReaderWithBadTable() throws SQLException
4411	4682	{
4412		Connection conn = DriverManager.getConnection("jdbc:relique:csv:class:" +
	4683	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:class:" +
4413	4684	TableReaderTester.class.getName());
4414		Statement stmt = conn.createStatement();
4415		try
4416		{
4417		stmt.executeQuery("SELECT * FROM X");
	4685	Statement stmt = conn.createStatement())
	4686	{
	4687	try
	4688	{
	4689	stmt.executeQuery("SELECT * FROM X");
	4690	fail("Should raise a java.sqlSQLException");
	4691	}
	4692	catch (SQLException e)
	4693	{
	4694	assertEquals("java.sql.SQLException: Table does not exist: X", "" + e);
	4695	}
	4696	}
	4697	}
	4698
	4699	@Test
	4700	public void testTableReaderWithBadReader() throws SQLException
	4701	{
	4702	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:class:" + TestCsvDriver.class.getName()))
	4703	{
4418	4704	fail("Should raise a java.sqlSQLException");
4419	4705	}
4420	4706	catch (SQLException e)
4421	4707	{
4422		assertEquals("java.sql.SQLException: Table does not exist: X", "" + e);
4423		}
4424		}
4425
4426		@Test
4427		public void testTableReaderWithBadReader() throws SQLException
4428		{
4429		try
4430		{
4431		DriverManager.getConnection("jdbc:relique:csv:class:" + TestCsvDriver.class.getName());
4432		fail("Should raise a java.sqlSQLException");
4433		}
4434		catch (SQLException e)
4435		{
4436	4708	assertEquals("java.sql.SQLException: " + CsvResources.getString("interfaceNotImplemented") + ": org.relique.io.TableReader: " + TestCsvDriver.class.getName(), "" + e);
4437	4709	}
4438	4710	}

4440	4712	@Test
4441	4713	public void testTableReaderTables() throws SQLException
4442	4714	{
4443		Connection conn = DriverManager.getConnection("jdbc:relique:csv:class:" +
	4715	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:class:" +
4444	4716	TableReaderTester.class.getName());
4445		ResultSet results = conn.getMetaData().getTables(null, null, "%", null);
4446		assertTrue(results.next());
4447		assertEquals("TABLE_NAME wrong", "AIRLINE", results.getString("TABLE_NAME"));
4448		assertTrue(results.next());
4449		assertEquals("TABLE_NAME wrong", "AIRPORT", results.getString("TABLE_NAME"));
4450		assertFalse(results.next());
	4717	ResultSet results = conn.getMetaData().getTables(null, null, "%", null))
	4718	{
	4719	assertTrue(results.next());
	4720	assertEquals("TABLE_NAME wrong", "AIRLINE", results.getString("TABLE_NAME"));
	4721	assertTrue(results.next());
	4722	assertEquals("TABLE_NAME wrong", "AIRPORT", results.getString("TABLE_NAME"));
	4723	assertFalse(results.next());
	4724	}
4451	4725	}
4452	4726
4453	4727	@Test
4454	4728	public void testTableReaderMetadata() throws SQLException
4455	4729	{
4456	4730	String url = "jdbc:relique:csv:class:" + TableReaderTester.class.getName();
4457		Connection conn = DriverManager.getConnection(url);
4458		assertEquals("URL is wrong", url, conn.getMetaData().getURL());
	4731	try (Connection conn = DriverManager.getConnection(url))
	4732	{
	4733	assertEquals("URL is wrong", url, conn.getMetaData().getURL());
	4734	}
4459	4735	}
4460	4736
4461	4737	@Test
4462	4738	public void testPropertiesInURL() throws SQLException
4463		{
4464		Properties props = new Properties();
4465
	4739	{
	4740	Properties props = new Properties();
	4741
4466	4742	/*
4467	4743	* Use same directory name logic as in CsvDriver.connect.
4468	4744	*/

4470	4746	if (!path.endsWith(File.separator))
4471	4747	path += File.separator;
4472	4748	String url = "jdbc:relique:csv:" + path + "?suppressHeaders=true&headerline=BLZ,NAME&commentChar=%23&fileExtension=.txt";
4473		Connection conn = DriverManager.getConnection(url, props);
4474		Statement stmt = conn.createStatement();
4475
4476		assertEquals("The URL is wrong", url, conn.getMetaData().getURL());
4477
4478		ResultSet results = stmt.executeQuery("SELECT * FROM banks");
4479		assertTrue(results.next());
4480		assertEquals("The BLZ is wrong", "10000000", results.getString("BLZ"));
4481		assertEquals("The NAME is wrong", "Bundesbank (Berlin)", results.getString("NAME"));
	4749	try (Connection conn = DriverManager.getConnection(url, props);
	4750	Statement stmt = conn.createStatement())
	4751	{
	4752	assertEquals("The URL is wrong", url, conn.getMetaData().getURL());
	4753
	4754	try (ResultSet results = stmt.executeQuery("SELECT * FROM banks"))
	4755	{
	4756	assertTrue(results.next());
	4757	assertEquals("The BLZ is wrong", "10000000", results.getString("BLZ"));
	4758	assertEquals("The NAME is wrong", "Bundesbank (Berlin)", results.getString("NAME"));
	4759	}
	4760	}
4482	4761	}
4483	4762
4484	4763	@Test

4493	4772	if (!path.endsWith(File.separator))
4494	4773	path += File.separator;
4495	4774	String url = "jdbc:relique:csv:" + path + "?separator=;&fileExtension=";
4496		Connection conn = DriverManager.getConnection(url, props);
4497		Statement stmt = conn.createStatement();
4498
4499		ResultSet results = stmt.executeQuery("SELECT * FROM sample");
4500		assertTrue(results.next());
4501		assertEquals("The ID is wrong", "Q123", results.getString("ID"));
	4775	try (Connection conn = DriverManager.getConnection(url, props);
	4776	Statement stmt = conn.createStatement();
	4777
	4778	ResultSet results = stmt.executeQuery("SELECT * FROM sample"))
	4779	{
	4780	assertTrue(results.next());
	4781	assertEquals("The ID is wrong", "Q123", results.getString("ID"));
	4782	}
4502	4783	}
4503	4784
4504	4785	@Test

4506	4787	{
4507	4788	Properties props = new Properties();
4508	4789	props.put("charset", "UTF-8");
4509		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
4510		+ filePath, props);
4511
4512		Statement stmt = conn.createStatement();
4513
4514		ResultSet results = stmt
4515		.executeQuery("select id from sample5 where name = '\u00C9rica Jeanine M\u00e9ndez M\u00e9ndez'");
4516
4517		assertTrue(results.next());
4518		assertEquals("Incorrect ID Value", "08", results.getString(1));
4519		assertFalse(results.next());
	4790	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	4791	+ filePath, props);
	4792
	4793	Statement stmt = conn.createStatement();
	4794
	4795	ResultSet results = stmt
	4796	.executeQuery("select id from sample5 where name = '\u00C9rica Jeanine M\u00e9ndez M\u00e9ndez'"))
	4797	{
	4798	assertTrue(results.next());
	4799	assertEquals("Incorrect ID Value", "08", results.getString(1));
	4800	assertFalse(results.next());
	4801	}
4520	4802	}
4521	4803
4522	4804	@Test
4523	4805	public void testDistinct() throws SQLException
4524	4806	{
4525		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	4807	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
4526	4808	+ filePath);
4527	4809
4528		Statement stmt = conn.createStatement();
4529
4530		ResultSet results = stmt.executeQuery("select distinct job from sample5");
4531
4532		assertTrue(results.next());
4533		assertEquals("Incorrect distinct value 1", "Piloto", results.getString(1));
4534		assertTrue(results.next());
4535		assertEquals("Incorrect distinct value 2", "Project Manager", results.getString(1));
4536		assertTrue(results.next());
4537		assertEquals("Incorrect distinct value 3", "Finance Manager", results.getString(1));
4538		assertTrue(results.next());
4539		assertEquals("Incorrect distinct value 4", "Office Manager", results.getString(1));
4540		assertTrue(results.next());
4541		assertEquals("Incorrect distinct value 5", "Office Employee", results.getString(1));
4542		assertFalse(results.next());
	4810	Statement stmt = conn.createStatement();
	4811
	4812	ResultSet results = stmt.executeQuery("select distinct job from sample5"))
	4813	{
	4814	assertTrue(results.next());
	4815	assertEquals("Incorrect distinct value 1", "Piloto", results.getString(1));
	4816	assertTrue(results.next());
	4817	assertEquals("Incorrect distinct value 2", "Project Manager", results.getString(1));
	4818	assertTrue(results.next());
	4819	assertEquals("Incorrect distinct value 3", "Finance Manager", results.getString(1));
	4820	assertTrue(results.next());
	4821	assertEquals("Incorrect distinct value 4", "Office Manager", results.getString(1));
	4822	assertTrue(results.next());
	4823	assertEquals("Incorrect distinct value 5", "Office Employee", results.getString(1));
	4824	assertFalse(results.next());
	4825	}
4543	4826	}
4544	4827
4545	4828	@Test
4546	4829	public void testDistinctWithAlias() throws SQLException
4547	4830	{
4548		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	4831	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
4549	4832	+ filePath);
4550	4833
4551		Statement stmt = conn.createStatement();
4552
4553		ResultSet results = stmt.executeQuery("select distinct S.job from sample5 S");
4554
4555		assertTrue(results.next());
4556		assertEquals("Incorrect distinct value 1", "Piloto", results.getString(1));
4557		assertTrue(results.next());
4558		assertEquals("Incorrect distinct value 2", "Project Manager", results.getString(1));
4559		assertTrue(results.next());
4560		assertEquals("Incorrect distinct value 3", "Finance Manager", results.getString(1));
4561		assertTrue(results.next());
4562		assertEquals("Incorrect distinct value 4", "Office Manager", results.getString(1));
4563		assertTrue(results.next());
4564		assertEquals("Incorrect distinct value 5", "Office Employee", results.getString(1));
4565		assertFalse(results.next());
	4834	Statement stmt = conn.createStatement();
	4835
	4836	ResultSet results = stmt.executeQuery("select distinct S.job from sample5 S"))
	4837	{
	4838	assertTrue(results.next());
	4839	assertEquals("Incorrect distinct value 1", "Piloto", results.getString(1));
	4840	assertTrue(results.next());
	4841	assertEquals("Incorrect distinct value 2", "Project Manager", results.getString(1));
	4842	assertTrue(results.next());
	4843	assertEquals("Incorrect distinct value 3", "Finance Manager", results.getString(1));
	4844	assertTrue(results.next());
	4845	assertEquals("Incorrect distinct value 4", "Office Manager", results.getString(1));
	4846	assertTrue(results.next());
	4847	assertEquals("Incorrect distinct value 5", "Office Employee", results.getString(1));
	4848	assertFalse(results.next());
	4849	}
4566	4850	}
4567	4851
4568	4852	@Test

4574	4858	props.put("fileExtension", ".txt");
4575	4859	props.put("commentChar", "#");
4576	4860	props.put("columnTypes", "Date,Integer,Integer,Integer,Integer,Double");
4577		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
4578
4579		Statement stmt = conn.createStatement();
4580
4581		ResultSet results = stmt.executeQuery("select distinct TO_ACCT, TO_BLZ from transactions where AMOUNT<50");
4582
4583		assertTrue(results.next());
4584		assertEquals("Incorrect distinct TO_ACCT value 1", 27234813, results.getInt(1));
4585		assertEquals("Incorrect distinct TO_BLZ value 1", 10020500, results.getInt(2));
4586		assertTrue(results.next());
4587		assertEquals("Incorrect distinct TO_ACCT value 2", 3670345, results.getInt(1));
4588		assertEquals("Incorrect distinct TO_BLZ value 2", 10010010, results.getInt(2));
4589		assertFalse(results.next());
	4861
	4862	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
	4863
	4864	Statement stmt = conn.createStatement();
	4865
	4866	ResultSet results = stmt.executeQuery("select distinct TO_ACCT, TO_BLZ from transactions where AMOUNT<50"))
	4867	{
	4868	assertTrue(results.next());
	4869	assertEquals("Incorrect distinct TO_ACCT value 1", 27234813, results.getInt(1));
	4870	assertEquals("Incorrect distinct TO_BLZ value 1", 10020500, results.getInt(2));
	4871	assertTrue(results.next());
	4872	assertEquals("Incorrect distinct TO_ACCT value 2", 3670345, results.getInt(1));
	4873	assertEquals("Incorrect distinct TO_BLZ value 2", 10010010, results.getInt(2));
	4874	assertFalse(results.next());
	4875	}
4590	4876	}
4591	4877
4592	4878	@Test
4593	4879	public void testNoTable() throws SQLException, ParseException
4594	4880	{
4595		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath);
4596		Statement stmt = conn.createStatement();
4597		ResultSet results = stmt.executeQuery("SELECT 'Hello', 'World' as W, 5+7");
4598
4599		assertTrue(results.next());
4600		ResultSetMetaData metadata = results.getMetaData();
4601		assertEquals("column 1 type is incorrect", Types.VARCHAR, metadata.getColumnType(1));
4602		assertEquals("column 2 type is incorrect", Types.VARCHAR, metadata.getColumnType(2));
4603		assertEquals("column 3 type is incorrect", Types.INTEGER, metadata.getColumnType(3));
4604
4605		assertEquals("column 2 name is incorrect", "W", metadata.getColumnName(2));
4606
4607		assertEquals("column 1 value is incorrect", "Hello", results.getString(1));
4608		assertEquals("column 2 value is incorrect", "World", results.getString(2));
4609		assertEquals("column 3 value is incorrect", 12, results.getInt(3));
4610		assertFalse(results.next());
	4881	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath);
	4882	Statement stmt = conn.createStatement();
	4883	ResultSet results = stmt.executeQuery("SELECT 'Hello', 'World' as W, 5+7"))
	4884	{
	4885	assertTrue(results.next());
	4886	ResultSetMetaData metadata = results.getMetaData();
	4887	assertEquals("column 1 type is incorrect", Types.VARCHAR, metadata.getColumnType(1));
	4888	assertEquals("column 2 type is incorrect", Types.VARCHAR, metadata.getColumnType(2));
	4889	assertEquals("column 3 type is incorrect", Types.INTEGER, metadata.getColumnType(3));
	4890
	4891	assertEquals("column 2 name is incorrect", "W", metadata.getColumnName(2));
	4892
	4893	assertEquals("column 1 value is incorrect", "Hello", results.getString(1));
	4894	assertEquals("column 2 value is incorrect", "World", results.getString(2));
	4895	assertEquals("column 3 value is incorrect", 12, results.getInt(3));
	4896	assertFalse(results.next());
	4897	}
4611	4898	}
4612	4899
4613	4900	@Test

4615	4902	{
4616	4903	Properties props = new Properties();
4617	4904	props.put("columnTypes", "Integer,String,String,Timestamp,Time");
4618		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
4619		+ filePath, props);
4620
4621		Statement stmt = conn.createStatement();
4622
4623		ResultSet results = stmt
4624		.executeQuery("SELECT ID FROM sample5 WHERE ID < 3");
4625		assertTrue(results.next());
4626		assertTrue(results.next());
4627		assertFalse(results.next());
4628		assertFalse(results.next());
4629		assertFalse(results.next());
	4905
	4906	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	4907	+ filePath, props);
	4908
	4909	Statement stmt = conn.createStatement();
	4910
	4911	ResultSet results = stmt
	4912	.executeQuery("SELECT ID FROM sample5 WHERE ID < 3"))
	4913	{
	4914	assertTrue(results.next());
	4915	assertTrue(results.next());
	4916	assertFalse(results.next());
	4917	assertFalse(results.next());
	4918	assertFalse(results.next());
	4919	}
4630	4920	}
4631	4921
4632	4922	@Test
4633	4923	public void testGetRow() throws SQLException
4634	4924	{
4635		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath);
4636
4637		Statement stmt = conn.createStatement();
4638
4639		// Select the ID and NAME columns from sample.csv
4640		ResultSet results = stmt.executeQuery("SELECT ID,NAME FROM sample");
4641
4642		assertEquals("incorrect row #", 0, results.getRow());
4643		assertFalse(results.isAfterLast());
4644		assertTrue(results.next());
4645		assertEquals("Incorrect ID Value", "Q123", results.getString("ID"));
4646		assertEquals("incorrect row #", 1, results.getRow());
4647		assertFalse(results.isAfterLast());
4648		assertTrue(results.next());
4649		assertEquals("incorrect row #", 2, results.getRow());
4650		assertTrue(results.next());
4651		assertEquals("incorrect row #", 3, results.getRow());
4652		assertTrue(results.next());
4653		assertEquals("incorrect row #", 4, results.getRow());
4654		assertTrue(results.next());
4655		assertEquals("incorrect row #", 5, results.getRow());
4656		assertTrue(results.next());
4657		assertEquals("incorrect row #", 6, results.getRow());
4658		assertFalse(results.next());
4659		assertEquals("incorrect row #", 0, results.getRow());
4660		assertTrue(results.isAfterLast());
4661
4662		results.close();
4663
4664		results = stmt.executeQuery("SELECT ID,NAME FROM sample ORDER BY ID");
4665
4666		assertEquals("incorrect row #", 0, results.getRow());
4667		assertFalse(results.isAfterLast());
4668		assertTrue(results.next());
4669		assertEquals("Incorrect ID Value", "A123", results.getString("ID"));
4670		assertEquals("incorrect row #", 1, results.getRow());
4671		assertFalse(results.isAfterLast());
4672		assertTrue(results.next());
4673		assertEquals("incorrect row #", 2, results.getRow());
4674		assertTrue(results.next());
4675		assertEquals("incorrect row #", 3, results.getRow());
4676		assertTrue(results.next());
4677		assertEquals("incorrect row #", 4, results.getRow());
4678		assertTrue(results.next());
4679		assertEquals("incorrect row #", 5, results.getRow());
4680		assertTrue(results.next());
4681		assertEquals("incorrect row #", 6, results.getRow());
4682		assertFalse(results.next());
4683		assertEquals("incorrect row #", 0, results.getRow());
4684		assertTrue(results.isAfterLast());
4685
4686		results.close();
4687
4688		results = stmt.executeQuery("SELECT COUNT(*) FROM sample");
4689
4690		assertEquals("incorrect row #", 0, results.getRow());
4691		assertFalse(results.isAfterLast());
4692		assertTrue(results.next());
4693		assertEquals("Incorrect COUNT Value", 6, results.getInt(1));
4694		assertEquals("incorrect row #", 1, results.getRow());
4695		assertFalse(results.isAfterLast());
4696		assertFalse(results.next());
4697		assertEquals("incorrect row #", 0, results.getRow());
4698		assertTrue(results.isAfterLast());
4699
4700		results.close();
4701
4702		// Test result set returning no rows.
4703		results = stmt.executeQuery("SELECT * FROM sample WHERE ID = 'unknown'");
4704
4705		assertEquals("incorrect row #", 0, results.getRow());
4706		assertFalse(results.isAfterLast());
4707		assertFalse(results.next());
4708		assertFalse(results.isAfterLast());
4709
4710		// clean up
4711		results.close();
4712		stmt.close();
4713		conn.close();
4714		}
4715
	4925	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath);
	4926
	4927	Statement stmt = conn.createStatement())
	4928	{
	4929	// Select the ID and NAME columns from sample.csv
	4930	try (ResultSet results = stmt.executeQuery("SELECT ID,NAME FROM sample"))
	4931	{
	4932	assertEquals("incorrect row #", 0, results.getRow());
	4933	assertFalse(results.isAfterLast());
	4934	assertTrue(results.next());
	4935	assertEquals("Incorrect ID Value", "Q123", results.getString("ID"));
	4936	assertEquals("incorrect row #", 1, results.getRow());
	4937	assertFalse(results.isAfterLast());
	4938	assertTrue(results.next());
	4939	assertEquals("incorrect row #", 2, results.getRow());
	4940	assertTrue(results.next());
	4941	assertEquals("incorrect row #", 3, results.getRow());
	4942	assertTrue(results.next());
	4943	assertEquals("incorrect row #", 4, results.getRow());
	4944	assertTrue(results.next());
	4945	assertEquals("incorrect row #", 5, results.getRow());
	4946	assertTrue(results.next());
	4947	assertEquals("incorrect row #", 6, results.getRow());
	4948	assertFalse(results.next());
	4949	assertEquals("incorrect row #", 0, results.getRow());
	4950	assertTrue(results.isAfterLast());
	4951	}
	4952
	4953	try (ResultSet results = stmt.executeQuery("SELECT ID,NAME FROM sample ORDER BY ID"))
	4954	{
	4955	assertEquals("incorrect row #", 0, results.getRow());
	4956	assertFalse(results.isAfterLast());
	4957	assertTrue(results.next());
	4958	assertEquals("Incorrect ID Value", "A123", results.getString("ID"));
	4959	assertEquals("incorrect row #", 1, results.getRow());
	4960	assertFalse(results.isAfterLast());
	4961	assertTrue(results.next());
	4962	assertEquals("incorrect row #", 2, results.getRow());
	4963	assertTrue(results.next());
	4964	assertEquals("incorrect row #", 3, results.getRow());
	4965	assertTrue(results.next());
	4966	assertEquals("incorrect row #", 4, results.getRow());
	4967	assertTrue(results.next());
	4968	assertEquals("incorrect row #", 5, results.getRow());
	4969	assertTrue(results.next());
	4970	assertEquals("incorrect row #", 6, results.getRow());
	4971	assertFalse(results.next());
	4972	assertEquals("incorrect row #", 0, results.getRow());
	4973	assertTrue(results.isAfterLast());
	4974	}
	4975
	4976	try (ResultSet results = stmt.executeQuery("SELECT COUNT(*) FROM sample"))
	4977	{
	4978	assertEquals("incorrect row #", 0, results.getRow());
	4979	assertFalse(results.isAfterLast());
	4980	assertTrue(results.next());
	4981	assertEquals("Incorrect COUNT Value", 6, results.getInt(1));
	4982	assertEquals("incorrect row #", 1, results.getRow());
	4983	assertFalse(results.isAfterLast());
	4984	assertFalse(results.next());
	4985	assertEquals("incorrect row #", 0, results.getRow());
	4986	assertTrue(results.isAfterLast());
	4987	}
	4988
	4989	// Test result set returning no rows.
	4990	try (ResultSet results = stmt.executeQuery("SELECT * FROM sample WHERE ID = 'unknown'"))
	4991	{
	4992	assertEquals("incorrect row #", 0, results.getRow());
	4993	assertFalse(results.isAfterLast());
	4994	assertFalse(results.next());
	4995	assertFalse(results.isAfterLast());
	4996	}
	4997	}
	4998	}
	4999
4716	5000	@Test
4717	5001	public void testNoCurrentRow() throws SQLException
4718	5002	{
4719		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath);
4720
4721		Statement stmt = conn.createStatement();
4722
4723		// Select the ID and NAME columns from sample.csv
4724		ResultSet results = stmt.executeQuery("SELECT ID,NAME FROM sample");
4725
4726		try
4727		{
4728		results.getString(1);
4729		fail("Should raise a java.sqlSQLException");
4730		}
4731		catch (SQLException e)
4732		{
4733		assertEquals("java.sql.SQLException: " + CsvResources.getString("noCurrentRow"), "" + e);
4734		}
4735
4736		// clean up
4737		results.close();
4738		stmt.close();
4739		conn.close();
	5003	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath);
	5004
	5005	Statement stmt = conn.createStatement();
	5006
	5007	// Select the ID and NAME columns from sample.csv
	5008	ResultSet results = stmt.executeQuery("SELECT ID,NAME FROM sample"))
	5009	{
	5010	try
	5011	{
	5012	results.getString(1);
	5013	fail("Should raise a java.sqlSQLException");
	5014	}
	5015	catch (SQLException e)
	5016	{
	5017	assertEquals("java.sql.SQLException: " + CsvResources.getString("noCurrentRow"), "" + e);
	5018	}
	5019	}
4740	5020	}
4741	5021
4742	5022	@Test
4743	5023	public void testWriteToCsv() throws SQLException, UnsupportedEncodingException, IOException
4744	5024	{
4745	5025	Properties props = new Properties();
4746		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
4747
4748		Statement stmt = conn.createStatement();
4749
4750		ResultSet results = stmt.executeQuery("SELECT * FROM sample");
4751		ByteArrayOutputStream byteStream = new ByteArrayOutputStream();
4752		PrintStream printStream = new PrintStream(byteStream);
4753
4754		/*
4755		* Check that writing ResultSet to CSV file generates exactly the same CSV file
4756		* that the query was originally read from.
4757		*/
4758		CsvDriver.writeToCsv(results, printStream, true);
4759
4760		BufferedReader reader1 = null;
4761		BufferedReader reader2 = null;
4762		try
4763		{
4764		reader1 = new BufferedReader(new FileReader(filePath + File.separator + "sample.csv"));
4765		reader2 = new BufferedReader(new StringReader(byteStream.toString("US-ASCII")));
4766		String line1 = reader1.readLine();
4767		String line2 = reader2.readLine();
4768
4769		while (line1 != null \|\| line2 != null)
4770		{
4771		assertTrue("line1 is null", line1 != null);
4772		assertTrue("line2 is null", line2 != null);
4773		assertEquals("lines do not match", line1, line2);
4774		line1 = reader1.readLine();
4775		line2 = reader2.readLine();
4776		}
4777		}
4778		finally
4779		{
4780		if (reader1 != null)
4781		reader1.close();
4782		if (reader2 != null)
4783		reader2.close();
4784		}
4785		results.close();
4786		stmt.close();
4787		conn.close();
4788		}
4789
	5026
	5027	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
	5028
	5029	Statement stmt = conn.createStatement();
	5030
	5031	ResultSet results = stmt.executeQuery("SELECT * FROM sample"))
	5032	{
	5033	ByteArrayOutputStream byteStream = new ByteArrayOutputStream();
	5034	PrintStream printStream = new PrintStream(byteStream);
	5035
	5036	/*
	5037	* Check that writing ResultSet to CSV file generates exactly the same CSV file
	5038	* that the query was originally read from.
	5039	*/
	5040	CsvDriver.writeToCsv(results, printStream, true);
	5041
	5042	try (BufferedReader reader1 = new BufferedReader(new FileReader(filePath + File.separator + "sample.csv"));
	5043	BufferedReader reader2 = new BufferedReader(new StringReader(byteStream.toString("US-ASCII"))))
	5044	{
	5045	String line1 = reader1.readLine();
	5046	String line2 = reader2.readLine();
	5047
	5048	while (line1 != null \|\| line2 != null)
	5049	{
	5050	assertTrue("line1 is null", line1 != null);
	5051	assertTrue("line2 is null", line2 != null);
	5052	assertEquals("lines do not match", line1, line2);
	5053	line1 = reader1.readLine();
	5054	line2 = reader2.readLine();
	5055	}
	5056	}
	5057	}
	5058	}
	5059
4790	5060	@Test
4791	5061	public void testWriteToCsvWithDates() throws SQLException, UnsupportedEncodingException, IOException
4792	5062	{

4803	5073	props.put("locale", Locale.US.toString());
4804	5074	}
4805	5075
4806		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
4807		+ filePath, props);
4808		Statement stmt = conn.createStatement();
4809		ResultSet results = stmt.executeQuery("SELECT * FROM sunil_date_time");
4810		ByteArrayOutputStream byteStream = new ByteArrayOutputStream();
4811		PrintStream printStream = new PrintStream(byteStream);
4812
4813		/*
4814		* Check that writing ResultSet to CSV file generates exactly the same CSV file
4815		* that the query was originally read from.
4816		*/
4817		boolean writeHeaderLine = true;
4818		CsvDriver.writeToCsv(results, printStream, writeHeaderLine);
4819
4820		BufferedReader reader1 = null;
4821		BufferedReader reader2 = null;
4822		try
4823		{
4824		reader1 = new BufferedReader(new FileReader(filePath + File.separator + "sunil_date_time.csv"));
4825		reader2 = new BufferedReader(new StringReader(byteStream.toString("US-ASCII")));
4826		String line1 = reader1.readLine();
4827		String line2 = reader2.readLine();
4828
4829		while (line1 != null \|\| line2 != null)
4830		{
4831		assertTrue("line1 is null", line1 != null);
4832		assertTrue("line2 is null", line2 != null);
4833		assertTrue("lines do not match", line1.equalsIgnoreCase(line2));
4834		line1 = reader1.readLine();
4835		line2 = reader2.readLine();
4836		}
4837		assertNull("line1 not empty", line1);
4838		assertNull("line2 not empty", line2);
4839		}
4840		finally
4841		{
4842		if (reader1 != null)
4843		reader1.close();
4844		if (reader2 != null)
4845		reader2.close();
	5076	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	5077	+ filePath, props);
	5078	Statement stmt = conn.createStatement();
	5079	ResultSet results = stmt.executeQuery("SELECT * FROM sunil_date_time"))
	5080	{
	5081	ByteArrayOutputStream byteStream = new ByteArrayOutputStream();
	5082	PrintStream printStream = new PrintStream(byteStream);
	5083
	5084	/*
	5085	* Check that writing ResultSet to CSV file generates exactly the same CSV file
	5086	* that the query was originally read from.
	5087	*/
	5088	boolean writeHeaderLine = true;
	5089	CsvDriver.writeToCsv(results, printStream, writeHeaderLine);
	5090
	5091	try (BufferedReader reader1 = new BufferedReader(new FileReader(filePath + File.separator + "sunil_date_time.csv"));
	5092	BufferedReader reader2 = new BufferedReader(new StringReader(byteStream.toString("US-ASCII"))))
	5093	{
	5094	String line1 = reader1.readLine();
	5095	String line2 = reader2.readLine();
	5096
	5097	while (line1 != null \|\| line2 != null)
	5098	{
	5099	assertTrue("line1 is null", line1 != null);
	5100	assertTrue("line2 is null", line2 != null);
	5101	assertTrue("lines do not match", line1.equalsIgnoreCase(line2));
	5102	line1 = reader1.readLine();
	5103	line2 = reader2.readLine();
	5104	}
	5105	assertNull("line1 not empty", line1);
	5106	assertNull("line2 not empty", line2);
	5107	}
4846	5108	}
4847	5109	}
4848	5110

4853	5115	Properties props = new Properties();
4854	5116	props.put("columnTypes", "Integer,String,Boolean");
4855	5117
4856		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
4857		+ filePath, props);
4858		Statement stmt = conn.createStatement();
4859		ResultSet results = stmt.executeQuery("SELECT * FROM bool");
4860
4861		assertTrue(results.next());
4862		assertEquals("incorrect I", false, results.getBoolean(1));
4863		assertEquals("incorrect J", true, results.getBoolean(2));
4864		assertEquals("incorrect K", false, results.getBoolean(3));
4865		assertEquals("incorrect L", true, results.getBoolean(4));
4866		assertTrue(results.next());
4867		assertEquals("incorrect I", true, results.getBoolean("I"));
4868		assertEquals("incorrect J", false, results.getBoolean("J"));
4869		assertEquals("incorrect K", false, results.getBoolean("K"));
4870		assertEquals("incorrect L", false, results.getBoolean("L"));
4871
4872		results.close();
4873		stmt.close();
4874		conn.close();
	5118	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	5119	+ filePath, props);
	5120	Statement stmt = conn.createStatement();
	5121	ResultSet results = stmt.executeQuery("SELECT * FROM bool"))
	5122	{
	5123	assertTrue(results.next());
	5124	assertEquals("incorrect I", false, results.getBoolean(1));
	5125	assertEquals("incorrect J", true, results.getBoolean(2));
	5126	assertEquals("incorrect K", false, results.getBoolean(3));
	5127	assertEquals("incorrect L", true, results.getBoolean(4));
	5128	assertTrue(results.next());
	5129	assertEquals("incorrect I", true, results.getBoolean("I"));
	5130	assertEquals("incorrect J", false, results.getBoolean("J"));
	5131	assertEquals("incorrect K", false, results.getBoolean("K"));
	5132	assertEquals("incorrect L", false, results.getBoolean("L"));
	5133	}
4875	5134	}
4876	5135
4877	5136	@Test
4878	5137	public void testExecuteSingleStatement() throws SQLException
4879	5138	{
4880		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	5139	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
4881	5140	+ filePath);
4882	5141
4883		Statement stmt = conn.createStatement();
4884
4885		boolean hasResults = stmt.execute("SELECT * FROM sample");
4886		assertTrue("execute hasResults", hasResults);
4887		ResultSet results = stmt.getResultSet();
4888		assertNotNull(results);
4889		assertTrue(results.next());
4890		assertEquals("The ID is wrong", "Q123", results.getString(1));
4891		assertFalse("getMoreResults", stmt.getMoreResults());
4892
4893		stmt.close();
4894		conn.close();
	5142	Statement stmt = conn.createStatement())
	5143	{
	5144	boolean hasResults = stmt.execute("SELECT * FROM sample");
	5145	assertTrue("execute hasResults", hasResults);
	5146	ResultSet results = stmt.getResultSet();
	5147	assertNotNull(results);
	5148	assertTrue(results.next());
	5149	assertEquals("The ID is wrong", "Q123", results.getString(1));
	5150	assertFalse("getMoreResults", stmt.getMoreResults());
	5151	}
4895	5152	}
4896	5153
4897	5154	@Test
4898	5155	public void testExecuteMultipleStatements() throws SQLException
4899	5156	{
4900		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	5157	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
4901	5158	+ filePath);
4902	5159
4903		Statement stmt = conn.createStatement();
4904
4905		boolean hasResults = stmt.execute("SELECT ID FROM sample;\nSELECT Name FROM sample2;");
4906		assertTrue("execute hasResults", hasResults);
4907		ResultSet results1 = stmt.getResultSet();
4908		assertNotNull(results1);
4909		assertTrue(results1.next());
4910		assertEquals("The ID is wrong", "Q123", results1.getString(1));
4911
4912		assertTrue("getMoreResults", stmt.getMoreResults());
4913		ResultSet results2 = stmt.getResultSet();
4914		assertNotNull(results2);
4915		assertTrue(results1.isClosed());
4916		assertTrue(results2.next());
4917		assertEquals("The Name is wrong", "Aman", results2.getString(1));
4918		assertFalse("getMoreResults", stmt.getMoreResults());
4919		assertTrue(results2.isClosed());
4920
4921		stmt.close();
4922		conn.close();
	5160	Statement stmt = conn.createStatement())
	5161	{
	5162	boolean hasResults = stmt.execute("SELECT ID FROM sample;\nSELECT Name FROM sample2;");
	5163	assertTrue("execute hasResults", hasResults);
	5164	try (ResultSet results1 = stmt.getResultSet())
	5165	{
	5166	assertNotNull(results1);
	5167	assertTrue(results1.next());
	5168	assertEquals("The ID is wrong", "Q123", results1.getString(1));
	5169
	5170	assertTrue("getMoreResults", stmt.getMoreResults());
	5171	try (ResultSet results2 = stmt.getResultSet())
	5172	{
	5173	assertNotNull(results2);
	5174	assertTrue(results1.isClosed());
	5175	assertTrue(results2.next());
	5176	assertEquals("The Name is wrong", "Aman", results2.getString(1));
	5177	assertFalse("getMoreResults", stmt.getMoreResults());
	5178	assertTrue(results2.isClosed());
	5179	}
	5180	}
	5181	}
4923	5182	}
4924	5183
4925	5184	@Test

4931	5190	props.put("function.PROPERTY", "java.lang.System.getProperty(String)");
4932	5191	props.put("function.RLIKE", "java.util.regex.Pattern.matches(String regex,CharSequence input)");
4933	5192	props.put("function.CURRENTTIMEMILLIS", "java.lang.System.currentTimeMillis()");
4934		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
4935
4936		Statement stmt = conn.createStatement();
4937
4938		ResultSet results = stmt.executeQuery("SELECT POW(C1, 2) FROM numeric");
4939		assertTrue(results.next());
4940		assertEquals("pow is wrong", 99 * 99, Math.round(results.getDouble(1)));
4941		assertTrue(results.next());
4942		assertEquals("pow is wrong", -22 * -22, Math.round(results.getDouble(1)));
4943
4944		results = stmt.executeQuery("SELECT BITCOUNT(C1) FROM numeric");
4945		assertTrue(results.next());
4946		assertEquals("bitcount is wrong", Integer.bitCount(99), results.getInt(1));
4947		assertTrue(results.next());
4948		assertEquals("bitcount is wrong", Integer.bitCount(-22), results.getInt(1));
4949
4950		String separator = System.getProperty("file.separator");
4951		results = stmt.executeQuery("SELECT PROPERTY('file.separator') \|\| ID FROM sample");
4952		assertTrue(results.next());
4953		assertEquals("property is wrong", separator + "Q123", results.getString(1));
4954		assertTrue(results.next());
4955		assertEquals("property is wrong", separator + "A123", results.getString(1));
4956
4957		results = stmt.executeQuery("SELECT * FROM sample WHERE RLIKE('.*234', ID) = 'true'");
4958		assertTrue(results.next());
4959		assertEquals("ID is wrong", "B234", results.getString(1));
4960		assertTrue(results.next());
4961		assertEquals("ID is wrong", "X234", results.getString(1));
4962		assertFalse(results.next());
4963
4964		long t1 = System.currentTimeMillis();
4965		results = stmt.executeQuery("SELECT CurrentTimeMillis()");
4966		assertTrue(results.next());
4967		long t = results.getLong(1);
4968		long t2 = System.currentTimeMillis();
4969		assertTrue("CurrentTimeMillis is wrong", t >= t1 && t <= t2);
	5193
	5194	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
	5195
	5196	Statement stmt = conn.createStatement())
	5197	{
	5198	try (ResultSet results = stmt.executeQuery("SELECT POW(C1, 2) FROM numeric"))
	5199	{
	5200	assertTrue(results.next());
	5201	assertEquals("pow is wrong", 99 * 99, Math.round(results.getDouble(1)));
	5202	assertTrue(results.next());
	5203	assertEquals("pow is wrong", -22 * -22, Math.round(results.getDouble(1)));
	5204	}
	5205
	5206	try (ResultSet results = stmt.executeQuery("SELECT BITCOUNT(C1) FROM numeric"))
	5207	{
	5208	assertTrue(results.next());
	5209	assertEquals("bitcount is wrong", Integer.bitCount(99), results.getInt(1));
	5210	assertTrue(results.next());
	5211	assertEquals("bitcount is wrong", Integer.bitCount(-22), results.getInt(1));
	5212	}
	5213
	5214	String separator = System.getProperty("file.separator");
	5215	try (ResultSet results = stmt.executeQuery("SELECT PROPERTY('file.separator') \|\| ID FROM sample"))
	5216	{
	5217	assertTrue(results.next());
	5218	assertEquals("property is wrong", separator + "Q123", results.getString(1));
	5219	assertTrue(results.next());
	5220	assertEquals("property is wrong", separator + "A123", results.getString(1));
	5221	}
	5222
	5223	try (ResultSet results = stmt.executeQuery("SELECT * FROM sample WHERE RLIKE('.*234', ID) = 'true'"))
	5224	{
	5225	assertTrue(results.next());
	5226	assertEquals("ID is wrong", "B234", results.getString(1));
	5227	assertTrue(results.next());
	5228	assertEquals("ID is wrong", "X234", results.getString(1));
	5229	assertFalse(results.next());
	5230	}
	5231
	5232	long t1 = System.currentTimeMillis();
	5233	try (ResultSet results = stmt.executeQuery("SELECT CurrentTimeMillis()"))
	5234	{
	5235	assertTrue(results.next());
	5236	long t = results.getLong(1);
	5237	long t2 = System.currentTimeMillis();
	5238	assertTrue("CurrentTimeMillis is wrong", t >= t1 && t <= t2);
	5239	}
	5240	}
4970	5241	}
4971	5242
4972	5243	@Test

4976	5247	props.put("columnTypes", "Byte,Short,Integer,Long,Float,Double,BigDecimal");
4977	5248	props.put("function.FORMAT", "java.lang.String.format(String, Object...)");
4978	5249
4979		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
4980
4981		Statement stmt = conn.createStatement();
4982
4983		ResultSet results = stmt.executeQuery("SELECT FORMAT('%04d%06d %x', C1, C2, 255) FROM numeric");
4984		assertTrue(results.next());
4985		assertEquals("format is wrong", "0099-01010 ff", results.getString(1));
4986		assertTrue(results.next());
4987		assertEquals("format is wrong", "-022000015 ff", results.getString(1));
	5250	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
	5251
	5252	Statement stmt = conn.createStatement();
	5253
	5254	ResultSet results = stmt.executeQuery("SELECT FORMAT('%04d%06d %x', C1, C2, 255) FROM numeric"))
	5255	{
	5256	assertTrue(results.next());
	5257	assertEquals("format is wrong", "0099-01010 ff", results.getString(1));
	5258	assertTrue(results.next());
	5259	assertEquals("format is wrong", "-022000015 ff", results.getString(1));
	5260	}
4988	5261	}
4989	5262
4990	5263	@Test

4993	5266	Properties props = new Properties();
4994	5267	props.put("function.BAD", "java.lang.Math.bad(double)");
4995	5268
4996		try
4997		{
4998		DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
	5269	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props))
	5270	{
4999	5271	fail("Should raise a java.sqlSQLException");
5000	5272	}
5001	5273	catch (SQLException e)

5007	5279	@Test
5008	5280	public void testSavepoints() throws SQLException
5009	5281	{
5010		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
5011		+ filePath);
5012
5013		Savepoint savepoint1 = conn.setSavepoint();
5014		savepoint1.getSavepointId();
5015		conn.rollback(savepoint1);
5016		Savepoint savepoint2 = conn.setSavepoint("name1");
5017		String name = savepoint2.getSavepointName();
5018		assertEquals("Incorrect Savepoint name", "name1", name);
5019		conn.rollback(savepoint2);
5020		conn.close();
5021
5022		try
5023		{
5024		conn.setSavepoint();
5025		fail("Should raise a java.sqlSQLException");
5026		}
5027		catch (SQLException e)
5028		{
5029		assertTrue(e.getMessage().contains(CsvResources.getString("closedConnection")));
	5282	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	5283	+ filePath))
	5284	{
	5285	Savepoint savepoint1 = conn.setSavepoint();
	5286	savepoint1.getSavepointId();
	5287	conn.rollback(savepoint1);
	5288	Savepoint savepoint2 = conn.setSavepoint("name1");
	5289	String name = savepoint2.getSavepointName();
	5290	assertEquals("Incorrect Savepoint name", "name1", name);
	5291	conn.rollback(savepoint2);
	5292	conn.close();
	5293
	5294	try
	5295	{
	5296	conn.setSavepoint();
	5297	fail("Should raise a java.sqlSQLException");
	5298	}
	5299	catch (SQLException e)
	5300	{
	5301	assertTrue(e.getMessage().contains(CsvResources.getString("closedConnection")));
	5302	}
5030	5303	}
5031	5304	}
5032	5305	}

+218

-230

src/test/java/org/relique/jdbc/csv/TestDbfDriver.java less more

46	46
47	47	/**
48	48	* This class is used to test the CsvJdbc driver.
49		*
	49	*
50	50	* @author Mario Frasca
51	51	*/
52	52	public class TestDbfDriver

71	71	{
72	72	fail("Driver is not in the CLASSPATH -> " + e);
73	73	}
74		toUTC = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
75		toUTC.setTimeZone(TimeZone.getTimeZone("UTC"));
	74	toUTC = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
	75	toUTC.setTimeZone(TimeZone.getTimeZone("UTC"));
76	76	}
77	77
78	78	/**
79	79	* This creates several sentences with where and tests they work
80		*
	80	*
81	81	* @throws SQLException
82	82	*/
83	83	@Test

88	88	Properties props = new Properties();
89	89	props.put("fileExtension", ".dbf");
90	90
91		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
92		+ filePath, props);
93
94		Statement stmt = conn.createStatement();
95
96		ResultSet results = stmt
97		.executeQuery("SELECT * FROM sample");
98		assertTrue(results.next());
99		assertEquals("The name is wrong", "Gianni", results
100		.getString("Name"));
101		assertTrue(results.next());
102		assertEquals("The name is wrong", "Reinout", results
103		.getString("Name"));
104		assertTrue(results.next());
105		assertEquals("The name is wrong", "Alex", results
106		.getString("Name"));
107		assertTrue(results.next());
108		assertEquals("The name is wrong", "Gianni", results
109		.getString("Name"));
110		assertTrue(results.next());
111		assertEquals("The name is wrong", "Mario", results
112		.getString("Name"));
113		assertFalse(results.next());
	91	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	92	+ filePath, props);
	93
	94	Statement stmt = conn.createStatement();
	95
	96	ResultSet results = stmt
	97	.executeQuery("SELECT * FROM sample"))
	98	{
	99	assertTrue(results.next());
	100	assertEquals("The name is wrong", "Gianni", results
	101	.getString("Name"));
	102	assertTrue(results.next());
	103	assertEquals("The name is wrong", "Reinout", results
	104	.getString("Name"));
	105	assertTrue(results.next());
	106	assertEquals("The name is wrong", "Alex", results
	107	.getString("Name"));
	108	assertTrue(results.next());
	109	assertEquals("The name is wrong", "Gianni", results
	110	.getString("Name"));
	111	assertTrue(results.next());
	112	assertEquals("The name is wrong", "Mario", results
	113	.getString("Name"));
	114	assertFalse(results.next());
	115	}
114	116	}
115	117	catch (DbfClassNotFoundException e)
116	118	{

129	131	Properties props = new Properties();
130	132	props.put("fileExtension", ".dbf");
131	133
132		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
133		+ filePath, props);
134
135		Statement stmt = conn.createStatement();
136
137		ResultSet results = stmt
138		.executeQuery("SELECT * FROM sample WHERE key = 'op'");
139		assertTrue(results.next());
140		assertEquals("The name is wrong", "Gianni", results
141		.getString("Name"));
142		assertEquals("The name is wrong", "debian", results
143		.getString("value"));
144		assertTrue(results.next());
145		assertEquals("The name is wrong", "Reinout", results
146		.getString("Name"));
147		assertEquals("The name is wrong", "ubuntu", results
148		.getString("value"));
149		assertTrue(results.next());
150		assertEquals("The name is wrong", "Alex", results
151		.getString("Name"));
152		assertEquals("The name is wrong", "windows", results
153		.getString("value"));
154		assertFalse(results.next());
	134	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	135	+ filePath, props);
	136
	137	Statement stmt = conn.createStatement();
	138
	139	ResultSet results = stmt
	140	.executeQuery("SELECT * FROM sample WHERE key = 'op'"))
	141	{
	142	assertTrue(results.next());
	143	assertEquals("The name is wrong", "Gianni", results
	144	.getString("Name"));
	145	assertEquals("The name is wrong", "debian", results
	146	.getString("value"));
	147	assertTrue(results.next());
	148	assertEquals("The name is wrong", "Reinout", results
	149	.getString("Name"));
	150	assertEquals("The name is wrong", "ubuntu", results
	151	.getString("value"));
	152	assertTrue(results.next());
	153	assertEquals("The name is wrong", "Alex", results
	154	.getString("Name"));
	155	assertEquals("The name is wrong", "windows", results
	156	.getString("value"));
	157	assertFalse(results.next());
	158	}
155	159	}
156	160	catch (DbfClassNotFoundException e)
157	161	{

170	174	Properties props = new Properties();
171	175	props.put("fileExtension", ".dbf");
172	176
173		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
174		+ filePath, props);
	177	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	178	+ filePath, props);
	179
	180	Statement stmt = conn.createStatement();
	181
	182	ResultSet results = stmt
	183	.executeQuery("SELECT * FROM sample WHERE key = 'todo'"))
	184	{
	185	assertTrue(results.next());
	186	assertEquals("The name is wrong", "Gianni", results
	187	.getString("Name"));
	188	assertEquals("The name is wrong", "none", results
	189	.getString("value"));
	190	assertTrue(results.next());
	191	assertEquals("The name is wrong", "Mario", results
	192	.getString("Name"));
	193	assertEquals("The name is wrong", "sleep", results
	194	.getString("value"));
	195	assertFalse(results.next());
	196	}
	197	}
	198	catch (DbfClassNotFoundException e)
	199	{
	200	/*
	201	* Skip test if classes for reading DBF files are not available.
	202	*/
	203	return;
	204	}
	205	}
	206
	207	@Test
	208	public void testWhereWithIsNull() throws SQLException
	209	{
	210	Properties props = new Properties();
	211	props.put("fileExtension", ".dbf");
	212
	213	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	214	+ filePath, props);
175	215
176	216	Statement stmt = conn.createStatement();
177	217
178	218	ResultSet results = stmt
179		.executeQuery("SELECT * FROM sample WHERE key = 'todo'");
180		assertTrue(results.next());
181		assertEquals("The name is wrong", "Gianni", results
182		.getString("Name"));
183		assertEquals("The name is wrong", "none", results
184		.getString("value"));
185		assertTrue(results.next());
186		assertEquals("The name is wrong", "Mario", results
187		.getString("Name"));
188		assertEquals("The name is wrong", "sleep", results
189		.getString("value"));
190		assertFalse(results.next());
191		}
192		catch (DbfClassNotFoundException e)
193		{
194		/*
195		* Skip test if classes for reading DBF files are not available.
196		*/
197		return;
198		}
199		}
200
201		@Test
202		public void testWhereWithIsNull() throws SQLException
203		{
204		try
205		{
206		Properties props = new Properties();
207		props.put("fileExtension", ".dbf");
208
209		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	219	.executeQuery("SELECT * FROM fox_samp WHERE COWNNAME IS NULL"))
	220	{
	221	assertFalse(results.next());
	222	}
	223	catch (DbfClassNotFoundException e)
	224	{
	225	/*
	226	* Skip test if classes for reading DBF files are not available.
	227	*/
	228	return;
	229	}
	230	}
	231
	232	@Test
	233	public void testTypedColumns() throws SQLException
	234	{
	235	Properties props = new Properties();
	236	props.put("fileExtension", ".dbf");
	237
	238	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
210	239	+ filePath, props);
211	240
212	241	Statement stmt = conn.createStatement();
213	242
214	243	ResultSet results = stmt
215		.executeQuery("SELECT * FROM fox_samp WHERE COWNNAME IS NULL");
216		assertFalse(results.next());
217		}
218		catch (DbfClassNotFoundException e)
219		{
220		/*
221		* Skip test if classes for reading DBF files are not available.
222		*/
223		return;
224		}
225		}
226
227		@Test
228		public void testTypedColumns() throws SQLException
229		{
230		try
231		{
232		Properties props = new Properties();
233		props.put("fileExtension", ".dbf");
234
235		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
236		+ filePath, props);
237
238		Statement stmt = conn.createStatement();
239
240		ResultSet results = stmt
241		.executeQuery("SELECT * FROM fox_samp");
	244	.executeQuery("SELECT * FROM fox_samp"))
	245	{
242	246	assertTrue(results.next());
243	247	ResultSetMetaData metadata = results.getMetaData();
244	248

261	265	@Test
262	266	public void testMemoColumn() throws SQLException
263	267	{
264		try
265		{
266		Properties props = new Properties();
267		props.put("fileExtension", ".dbf");
268
269		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
270
271		Statement stmt = conn.createStatement();
272
273		ResultSet results = stmt.executeQuery("SELECT NOTE FROM xbase");
	268	Properties props = new Properties();
	269	props.put("fileExtension", ".dbf");
	270
	271	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
	272
	273	Statement stmt = conn.createStatement();
	274
	275	ResultSet results = stmt.executeQuery("SELECT NOTE FROM xbase"))
	276	{
274	277	assertTrue(results.next());
275	278	assertEquals("The NOTE is wrong", "This is a memo fore record no one", results.getString(1));
276	279	assertTrue(results.next());

291	294	@Test
292	295	public void testFloatColumn() throws SQLException
293	296	{
294		try
295		{
296		Properties props = new Properties();
297		props.put("fileExtension", ".dbf");
298
299		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
300
301		Statement stmt = conn.createStatement();
302
303		ResultSet results = stmt.executeQuery("SELECT * FROM d");
	297	Properties props = new Properties();
	298	props.put("fileExtension", ".dbf");
	299
	300	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
	301
	302	Statement stmt = conn.createStatement();
	303
	304	ResultSet results = stmt.executeQuery("SELECT * FROM d"))
	305	{
304	306	assertTrue(results.next());
305	307	long l = Math.round(7.63 * 1000);
306	308	assertEquals("The floatfield is wrong", l, Math.round(results.getDouble(1) * 1000));

318	320	@Test
319	321	public void testColumnDisplaySizes() throws SQLException
320	322	{
321		try
322		{
323		Properties props = new Properties();
324		props.put("fileExtension", ".dbf");
325
326		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	323	Properties props = new Properties();
	324	props.put("fileExtension", ".dbf");
	325
	326	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
327	327	+ filePath, props);
328	328
329	329	Statement stmt = conn.createStatement();
330	330
331	331	ResultSet results = stmt
332		.executeQuery("SELECT * FROM fox_samp");
	332	.executeQuery("SELECT * FROM fox_samp"))
	333	{
333	334	assertTrue(results.next());
334	335	ResultSetMetaData metadata = results.getMetaData();
335	336

349	350	@Test
350	351	public void testDatabaseMetadataTables() throws SQLException
351	352	{
352		try
353		{
354		Properties props = new Properties();
355		props.put("fileExtension", ".dbf");
356
357		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
358		+ filePath, props);
359		DatabaseMetaData metadata = conn.getMetaData();
360		ResultSet results = metadata.getTables(null, null, "%", null);
	353	Properties props = new Properties();
	354	props.put("fileExtension", ".dbf");
	355
	356	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	357	+ filePath, props);
	358	ResultSet results = conn.getMetaData().getTables(null, null, "%", null))
	359	{
361	360	Set<String> target = new HashSet<String>();
362	361	target.add("sample");
363	362	target.add("fox_samp");

388	387	return;
389	388	}
390	389	}
391
	390
392	391	@Test
393	392	public void testDatabaseMetadataTablesPattern() throws SQLException
394	393	{
395		try
396		{
397		Properties props = new Properties();
398		props.put("fileExtension", ".dbf");
399
400		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
401		+ filePath, props);
402		DatabaseMetaData metadata = conn.getMetaData();
	394	Properties props = new Properties();
	395	props.put("fileExtension", ".dbf");
	396
	397	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	398	+ filePath, props);
403	399	// Get tables matching only this pattern
404		ResultSet results = metadata.getTables(null, null, "x%", new String[]{"TABLE"});
405
	400	ResultSet results = conn.getMetaData().getTables(null, null, "x%", new String[]{"TABLE"}))
	401	{
406	402	assertTrue(results.next());
407	403	assertEquals("Incorrect table name", "xbase", results.getString("TABLE_NAME"));
408	404	assertFalse(results.next());

419	415	@Test
420	416	public void testDatabaseMetadataColumns() throws SQLException
421	417	{
422		try
423		{
424		Properties props = new Properties();
425		props.put("fileExtension", ".dbf");
426
427		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
428		+ filePath, props);
429		DatabaseMetaData metadata = conn.getMetaData();
430		ResultSet results = metadata.getColumns(null, null, "sample", "%");
	418	Properties props = new Properties();
	419	props.put("fileExtension", ".dbf");
	420
	421	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	422	+ filePath, props);
	423	ResultSet results = conn.getMetaData().getColumns(null, null, "sample", "%"))
	424	{
431	425	assertTrue(results.next());
432	426	assertEquals("Incorrect table name", "sample", results.getString("TABLE_NAME"));
433	427	assertEquals("Incorrect column name", "NAME", results.getString("COLUMN_NAME"));

449	443	@Test
450	444	public void testDatabaseMetadataColumnsPattern() throws SQLException
451	445	{
452		try
453		{
454		Properties props = new Properties();
455		props.put("fileExtension", ".dbf");
456
457		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
458		+ filePath, props);
459		DatabaseMetaData metadata = conn.getMetaData();
460		ResultSet results = metadata.getColumns(null, null, "x%", "M%");
	446	Properties props = new Properties();
	447	props.put("fileExtension", ".dbf");
	448
	449	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	450	+ filePath, props);
	451	ResultSet results = conn.getMetaData().getColumns(null, null, "x%", "M%"))
	452	{
461	453	assertTrue(results.next());
462	454	assertEquals("Incorrect table name", "xbase", results.getString("TABLE_NAME"));
463	455	assertEquals("Incorrect column name", "MSG", results.getString("COLUMN_NAME"));

478	470	@Test
479	471	public void testGetNumeric() throws SQLException
480	472	{
481		try
482		{
483		Properties props = new Properties();
484		props.put("fileExtension", ".dbf");
485
486		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
487
488		Statement stmt = conn.createStatement();
489
490		ResultSet results = stmt.executeQuery("SELECT * FROM fox_samp");
	473	Properties props = new Properties();
	474	props.put("fileExtension", ".dbf");
	475
	476	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
	477
	478	Statement stmt = conn.createStatement();
	479
	480	ResultSet results = stmt.executeQuery("SELECT * FROM fox_samp"))
	481	{
491	482	assertTrue(results.next());
492	483	assertEquals("The NCOUNTYCOD is wrong", 33, results.getByte("NCOUNTYCOD"));
493	484	assertEquals("The NCOUNTYCOD is wrong", 33, results.getShort("NCOUNTYCOD"));
494	485	assertEquals("The NTAXYEAR is wrong", 2011, results.getInt("NTAXYEAR"));
495	486	assertEquals("The NNOTFCV is wrong", 0, results.getLong("NNOTFCV"));
496	487	assertEquals("The NASSASSRAT is wrong", 7250, Math.round(results.getFloat("NASSASSRAT") * 1000));
497		assertEquals("The NASSASSRAT is wrong", 7250, Math.round(results.getDouble("NASSASSRAT") * 1000));
498		assertFalse(results.next());
499		}
500		catch (DbfClassNotFoundException e)
501		{
502		/*
503		* Skip test if classes for reading DBF files are not available.
504		*/
505		return;
506		}
507		}
508
	488	assertEquals("The NASSASSRAT is wrong", 7250, Math.round(results.getDouble("NASSASSRAT") * 1000));
	489	assertFalse(results.next());
	490	}
	491	catch (DbfClassNotFoundException e)
	492	{
	493	/*
	494	* Skip test if classes for reading DBF files are not available.
	495	*/
	496	return;
	497	}
	498	}
	499
509	500	@Test
510	501	public void testGetDate() throws SQLException
511	502	{
512		try
513		{
514		Properties props = new Properties();
515		props.put("fileExtension", ".dbf");
516
517		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
518
519		Statement stmt = conn.createStatement();
520
521		ResultSet results = stmt.executeQuery("SELECT DASSDATE FROM fox_samp");
	503	Properties props = new Properties();
	504	props.put("fileExtension", ".dbf");
	505
	506	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
	507
	508	Statement stmt = conn.createStatement();
	509
	510	ResultSet results = stmt.executeQuery("SELECT DASSDATE FROM fox_samp"))
	511	{
522	512	assertTrue(results.next());
523	513	assertEquals("The DASSDATE is wrong", Date.valueOf("2012-12-25"), results.getDate(1));
524	514	}

530	520	return;
531	521	}
532	522	}
533
	523
534	524	@Test
535	525	public void testGetTimestamp() throws SQLException
536	526	{
537		try
538		{
539		Properties props = new Properties();
540		props.put("fileExtension", ".dbf");
541
542		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
543
544		Statement stmt = conn.createStatement();
545
546		ResultSet results = stmt.executeQuery("SELECT DASSDATE FROM fox_samp");
	527	Properties props = new Properties();
	528	props.put("fileExtension", ".dbf");
	529
	530	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
	531
	532	Statement stmt = conn.createStatement();
	533
	534	ResultSet results = stmt.executeQuery("SELECT DASSDATE FROM fox_samp"))
	535	{
547	536	assertTrue(results.next());
548	537	assertEquals("The DASSDATE is wrong", Timestamp.valueOf("2012-12-25 00:00:00"),
549	538	results.getTimestamp(1));

556	545	return;
557	546	}
558	547	}
559
	548
560	549	@Test
561	550	public void testCharset() throws SQLException
562	551	{
563		try
564		{
565		Properties props = new Properties();
566		props.put("fileExtension", ".dbf");
567		props.put("charset", "ISO-8859-1");
568
569		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
570
571		Statement stmt = conn.createStatement();
572
573		ResultSet results = stmt.executeQuery("SELECT HOTELNAME FROM hotel");
	552	Properties props = new Properties();
	553	props.put("fileExtension", ".dbf");
	554	props.put("charset", "ISO-8859-1");
	555
	556	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
	557
	558	Statement stmt = conn.createStatement();
	559
	560	ResultSet results = stmt.executeQuery("SELECT HOTELNAME FROM hotel"))
	561	{
574	562	assertTrue(results.next());
575	563	assertEquals("The HOTELNAME is wrong", "M\u00DCNCHEN HOTEL", results.getString(1));
576	564	assertTrue(results.next());

+39

-40

src/test/java/org/relique/jdbc/csv/TestDoubleQuoting.java less more

48	48	try
49	49	{
50	50	Class.forName("org.relique.jdbc.csv.CsvDriver");
51		}
	51	}
52	52	catch (ClassNotFoundException e)
53	53	{
54	54	fail("Driver is not in the CLASSPATH -> " + e);

60	60	{
61	61	Properties props = new Properties();
62	62
63		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
	63	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
64	64
65		Statement stmt = conn.createStatement();
	65	Statement stmt = conn.createStatement();
66	66
67		ResultSet rs1 = stmt.executeQuery("SELECT * FROM \"C D\"");
68		assertTrue(rs1.next());
	67	ResultSet rs1 = stmt.executeQuery("SELECT * FROM \"C D\""))
	68	{
	69	assertTrue(rs1.next());
	70	}
	71	}
69	72
70		rs1.close();
71		stmt.close();
72		}
73
74	73	@Test
75	74	public void testQuotedColumnNames() throws SQLException
76	75	{
77	76	Properties props = new Properties();
78	77	props.put("columnTypes", "Integer,Integer,Integer,Integer,Integer");
79	78
80		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
	79	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
81	80
82		Statement stmt = conn.createStatement();
	81	Statement stmt = conn.createStatement();
83	82
84		ResultSet rs1 = stmt.executeQuery("SELECT \"A\", \"B\" + 100, \"[A]\", \"A-B\", \"A B\" FROM \"C D\"");
85		assertEquals("Column name A is wrong", "A", rs1.getMetaData().getColumnName(1));
	83	ResultSet rs1 = stmt.executeQuery("SELECT \"A\", \"B\" + 100, \"[A]\", \"A-B\", \"A B\" FROM \"C D\""))
	84	{
	85	assertEquals("Column name A is wrong", "A", rs1.getMetaData().getColumnName(1));
86	86
87		assertEquals("Column name [A] is wrong", "[A]", rs1.getMetaData().getColumnName(3));
88		assertEquals("Column name A-B is wrong", "A-B", rs1.getMetaData().getColumnName(4));
89		assertEquals("Column name A B is wrong", "A B", rs1.getMetaData().getColumnName(5));
90		assertTrue(rs1.next());
91		assertEquals("The A is wrong", 1, rs1.getInt("A"));
92		assertEquals("The [A] is wrong", 3, rs1.getInt("[A]"));
93		assertEquals("The A-B is wrong", 4, rs1.getInt("A-B"));
94		assertEquals("The A-B is wrong", 5, rs1.getInt("A B"));
95		assertTrue(rs1.next());
96		assertEquals("The A is wrong", 6, rs1.getInt(1));
97		assertEquals("The B + 100 is wrong", 7 + 100, rs1.getInt(2));
98		assertEquals("The [A] is wrong", 8, rs1.getInt(3));
99		assertEquals("The A-B is wrong", 9, rs1.getInt(4));
100		assertEquals("The A-B is wrong", 10, rs1.getInt(5));
101		rs1.close();
102		stmt.close();
	87	assertEquals("Column name [A] is wrong", "[A]", rs1.getMetaData().getColumnName(3));
	88	assertEquals("Column name A-B is wrong", "A-B", rs1.getMetaData().getColumnName(4));
	89	assertEquals("Column name A B is wrong", "A B", rs1.getMetaData().getColumnName(5));
	90	assertTrue(rs1.next());
	91	assertEquals("The A is wrong", 1, rs1.getInt("A"));
	92	assertEquals("The [A] is wrong", 3, rs1.getInt("[A]"));
	93	assertEquals("The A-B is wrong", 4, rs1.getInt("A-B"));
	94	assertEquals("The A-B is wrong", 5, rs1.getInt("A B"));
	95	assertTrue(rs1.next());
	96	assertEquals("The A is wrong", 6, rs1.getInt(1));
	97	assertEquals("The B + 100 is wrong", 7 + 100, rs1.getInt(2));
	98	assertEquals("The [A] is wrong", 8, rs1.getInt(3));
	99	assertEquals("The A-B is wrong", 9, rs1.getInt(4));
	100	assertEquals("The A-B is wrong", 10, rs1.getInt(5));
	101	}
103	102	}
104
	103
105	104	@Test
106	105	public void testQuotedTableAlias() throws SQLException
107	106	{
108	107	Properties props = new Properties();
	108	String alias = "\"http://www.google.com\"";
109	109
110		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
	110	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
111	111
112		Statement stmt = conn.createStatement();
	112	Statement stmt = conn.createStatement();
113	113
114		String alias = "\"http://www.google.com\"";
115		ResultSet rs1 = stmt.executeQuery("SELECT " + alias + ".ID, " + alias + ".\"EXTRA_FIELD\" " +
116		"FROM sample AS " + alias);
117		assertTrue(rs1.next());
118		assertEquals("The ID is wrong", "Q123", rs1.getString(1));
119		assertEquals("The EXTRA_FIELD is wrong", "F", rs1.getString(2));
120	114
121		rs1.close();
122		stmt.close();
	115	ResultSet rs1 = stmt.executeQuery("SELECT " + alias + ".ID, " + alias + ".\"EXTRA_FIELD\" " +
	116	"FROM sample AS " + alias))
	117	{
	118	assertTrue(rs1.next());
	119	assertEquals("The ID is wrong", "Q123", rs1.getString(1));
	120	assertEquals("The EXTRA_FIELD is wrong", "F", rs1.getString(2));
	121	}
123	122	}
124	123	}

+81

-119

src/test/java/org/relique/jdbc/csv/TestFileSetInputStream.java less more

61	61	@Test
62	62	public void testGlueAsTrailing() throws IOException
63	63	{
64		BufferedReader inputRef = null;
65		BufferedReader inputTest = null;
66
67		try
68		{
69		inputRef = new BufferedReader(new InputStreamReader(
	64	try (BufferedReader inputRef = new BufferedReader(new InputStreamReader(
70	65	new FileInputStream(filePath + "test-glued-trailing.txt")));
71	66
72		inputTest = new BufferedReader(new InputStreamReader(
	67	BufferedReader inputTest = new BufferedReader(new InputStreamReader(
73	68	new FileSetInputStream(filePath,
74	69	"test-([0-9]{3})-([0-9]{8}).txt", new String[] {
75		"location", "file_date" }, ",", false, false, null, 0)));
76
	70	"location", "file_date" }, ",", false, false, null, 0, null))))
	71	{
77	72	Set<String> refSet = new HashSet<String>();
78	73	Set<String> testSet = new HashSet<String>();
79	74	inputRef.readLine();

90	85	assertTrue("refSet contains testSet", refSet.containsAll(testSet));
91	86	assertTrue("testSet contains refSet", testSet.containsAll(refSet));
92	87	}
93		finally
94		{
95		if (inputRef != null)
96		inputRef.close();
97		if (inputTest != null)
98		inputTest.close();
99		}
100	88	}
101	89
102	90	@Test
103	91	public void testGlueAsLeading() throws IOException
104	92	{
105		BufferedReader inputRef = null;
106		BufferedReader inputTest = null;
107
108		try
109		{
110		inputRef = new BufferedReader(new InputStreamReader(
	93	try (BufferedReader inputRef = new BufferedReader(new InputStreamReader(
111	94	new FileInputStream(filePath + "test-glued-leading.txt")));
112	95
113		inputTest = new BufferedReader(new InputStreamReader(
	96	BufferedReader inputTest = new BufferedReader(new InputStreamReader(
114	97	new FileSetInputStream(filePath,
115	98	"test-([0-9]{3})-([0-9]{8}).txt", new String[] {
116		"location", "file_date" }, ",", true, false, null, 0)));
117
	99	"location", "file_date" }, ",", true, false, null, 0, null))))
	100	{
118	101	Set<String> refSet = new HashSet<String>();
119	102	Set<String> testSet = new HashSet<String>();
120	103	inputRef.readLine();

131	114	assertTrue("refSet contains testSet", refSet.containsAll(testSet));
132	115	assertTrue("testSet contains refSet", testSet.containsAll(refSet));
133	116	}
134		finally
135		{
136		if (inputRef != null)
137		inputRef.close();
138		if (inputTest != null)
139		inputTest.close();
140		}
141	117	}
142	118
143	119	@Test
144	120	public void testGlueAsLeadingHeaderless() throws IOException
145	121	{
146		BufferedReader inputRef = null;
147		BufferedReader inputTest = null;
148
149		try
150		{
151		inputRef = new BufferedReader(new InputStreamReader(
	122	try (BufferedReader inputRef = new BufferedReader(new InputStreamReader(
152	123	new FileInputStream(filePath + "headerless-glued-leading.txt")));
153	124
154		inputTest = new BufferedReader(new InputStreamReader(
	125	BufferedReader inputTest = new BufferedReader(new InputStreamReader(
155	126	new FileSetInputStream(filePath,
156	127	"headerless-([0-9]{3})-([0-9]{8}).txt", new String[] {
157		"location", "file_date" }, ",", true, true, null, 0)));
158
159		Set<String> refSet = new HashSet<String>();
160		Set<String> testSet = new HashSet<String>();
161		String lineRef, lineTest;
162		do
163		{
164		lineRef = inputRef.readLine();
165		lineTest = inputTest.readLine();
166		refSet.add(lineRef);
167		testSet.add(lineTest);
168		}
169		while (lineRef != null && lineTest != null);
170		assertTrue("refSet contains testSet", refSet.containsAll(testSet));
171		assertTrue("testSet contains refSet", testSet.containsAll(refSet));
172		}
173		finally
174		{
175		if (inputRef != null)
176		inputRef.close();
177		if (inputTest != null)
178		inputTest.close();
	128	"location", "file_date" }, ",", true, true, null, 0, null))))
	129	{
	130	Set<String> refSet = new HashSet<String>();
	131	Set<String> testSet = new HashSet<String>();
	132	String lineRef, lineTest;
	133	do
	134	{
	135	lineRef = inputRef.readLine();
	136	lineTest = inputTest.readLine();
	137	refSet.add(lineRef);
	138	testSet.add(lineTest);
	139	}
	140	while (lineRef != null && lineTest != null);
	141	assertTrue("refSet contains testSet", refSet.containsAll(testSet));
	142	assertTrue("testSet contains refSet", testSet.containsAll(refSet));
179	143	}
180	144	}
181	145
182	146	@Test
183	147	public void testGlueAsEmpty() throws IOException
184	148	{
185		BufferedReader inputRef = null;
186		BufferedReader inputTest = null;
187
188		try
189		{
190		inputRef = new BufferedReader(new InputStreamReader(
	149	try (BufferedReader inputRef = new BufferedReader(new InputStreamReader(
191	150	new FileInputStream(filePath + "empty-glued.txt")));
192	151
193		inputTest = new BufferedReader(new InputStreamReader(
	152	BufferedReader inputTest = new BufferedReader(new InputStreamReader(
194	153	new FileSetInputStream(filePath,
195	154	"empty-([0-9]+).txt", new String[] {
196		"EMPTY_ID"}, ",", false, false, null, 0)));
197
198		Set<String> refSet = new HashSet<String>();
199		Set<String> testSet = new HashSet<String>();
200		String lineRef, lineTest;
201		do
202		{
203		lineRef = inputRef.readLine();
204		lineTest = inputTest.readLine();
205		refSet.add(lineRef);
206		testSet.add(lineTest);
207		}
208		while (lineRef != null && lineTest != null);
209		assertTrue("refSet contains testSet", refSet.containsAll(testSet));
210		assertTrue("testSet contains refSet", testSet.containsAll(refSet));
211		}
212		finally
213		{
214		if (inputRef != null)
215		inputRef.close();
216		if (inputTest != null)
217		inputTest.close();
	155	"EMPTY_ID"}, ",", false, false, null, 0, null))))
	156	{
	157	Set<String> refSet = new HashSet<String>();
	158	Set<String> testSet = new HashSet<String>();
	159	String lineRef, lineTest;
	160	do
	161	{
	162	lineRef = inputRef.readLine();
	163	lineTest = inputTest.readLine();
	164	refSet.add(lineRef);
	165	testSet.add(lineTest);
	166	}
	167	while (lineRef != null && lineTest != null);
	168	assertTrue("refSet contains testSet", refSet.containsAll(testSet));
	169	assertTrue("testSet contains refSet", testSet.containsAll(refSet));
218	170	}
219	171	}
220	172
221	173	@Test
222	174	public void testGlueAsLeadingLastLineNoNewline() throws IOException
223	175	{
224		BufferedReader inputTest = null;
225
226		try
227		{
228		String separator = ",";
229
230		// Test CSV files with no '\n' on last line
231		inputTest = new BufferedReader(new InputStreamReader(
	176	String separator = ",";
	177
	178	// Test CSV files with no '\n' on last line
	179	try (BufferedReader inputTest = new BufferedReader(new InputStreamReader(
232	180	new FileSetInputStream(filePath,
233	181	"petr-([0-9]{3})-([0-9]{3}).csv", new String[] {
234		"part1", "part2" }, separator, true, true, null, 0)));
235
	182	"part1", "part2" }, separator, true, true, null, 0, null))))
	183	{
236	184	String lineTest = inputTest.readLine();
237	185	while (lineTest != null)
238	186	{

244	192	lineTest = inputTest.readLine();
245	193	}
246	194	}
247		finally
248		{
249		if (inputTest != null)
250		inputTest.close();
251		}
252		}
253
	195	}
	196
254	197	@Test
255	198	public void testFileSetInputStreamClose() throws IOException
256	199	{
257		FileSetInputStream in = new FileSetInputStream(filePath,
	200	try (FileSetInputStream in = new FileSetInputStream(filePath,
258	201	"test-([0-9]{3})-([0-9]{8}).txt", new String[] {
259		"location", "file_date"}, ",", false, false, null, 0);
260
261		in.read();
262		in.read();
263		in.close();
264		try
	202	"location", "file_date"}, ",", false, false, null, 0, null))
265	203	{
266	204	in.read();
267		fail("expected exception java.io.IOException");
268		}
269		catch (IOException e)
270		{
271		assertTrue(("" + e).contains("IOException"));
	205	in.read();
	206	in.close();
	207	try
	208	{
	209	in.read();
	210	fail("expected exception java.io.IOException");
	211	}
	212	catch (IOException e)
	213	{
	214	assertTrue(("" + e).contains("IOException"));
	215	}
	216	}
	217	}
	218
	219	@Test
	220	public void testFileSetCharsetUtf16le() throws IOException
	221	{
	222	String charset = "UTF-16LE";
	223	try (BufferedReader in = new BufferedReader(new InputStreamReader(
	224	new FileSetInputStream(filePath,
	225	"utf16le_(\\d+).txt", new String[] {
	226	"date"}, "\|", false, false, null, 0, charset), charset)))
	227	{
	228	String line = in.readLine();
	229	assertEquals("Col1\|Col2\|Some third\|4th\|date", line);
	230	line = in.readLine();
	231	assertEquals("1\|01.10.2018\|-4,4\|1111\|01102018", line);
	232	line = in.readLine();
	233	assertEquals("2\|04.11.2020\|-2,2\|2222\|04112020", line);
272	234	}
273	235	}
274	236	}

+176

-156

src/test/java/org/relique/jdbc/csv/TestFixedWidthFiles.java less more

58	58
59	59	@Test
60	60	public void testFixedWidth() throws SQLException
61		{
	61	{
62	62	Properties props = new Properties();
63	63	props.put("fileExtension", ".txt");
64	64	props.put("fixedWidths", "1-16,17-24,25-27,35-42,43-50,51-58");
65	65
66		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
67
68		Statement stmt = conn.createStatement();
69
70		// GERMANY Euro EUR 0.7616450.7632460.002102
71		ResultSet rs1 = stmt.executeQuery("SELECT * FROM currency-exchange-rates-fixed");
72		assertTrue(rs1.next());
73		assertEquals("Country rate is wrong", "GERMANY", rs1.getString("Country"));
74		assertEquals("Currency rate is wrong", "Euro", rs1.getString("Currency"));
75		assertEquals("ISO rate is wrong", "EUR", rs1.getString("ISO"));
76		assertEquals("YESTERDY rate is wrong", "0.761645", rs1.getString("YESTERDY"));
77		assertEquals("TODAY_ rate is wrong", "0.763246", rs1.getString("TODAY_"));
78		assertEquals("% Change rate is wrong", "0.002102", rs1.getString("% Change"));
79
80		assertTrue(rs1.next());
81		assertEquals("Country rate is wrong", "GREECE", rs1.getString(1));
82		assertEquals("Currency rate is wrong", "Euro", rs1.getString(2));
83		assertEquals("ISO rate is wrong", "EUR", rs1.getString(3));
84		assertEquals("YESTERDY rate is wrong", "0.761645", rs1.getString(4));
85		assertEquals("TODAY_ rate is wrong", "0.763246", rs1.getString(5));
86		assertEquals("% Change rate is wrong", "0.002102", rs1.getString(6));
87
88		assertTrue(rs1.next());
	66	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
	67
	68	Statement stmt = conn.createStatement();
	69
	70	// GERMANY Euro EUR 0.7616450.7632460.002102
	71	ResultSet rs1 = stmt.executeQuery("SELECT * FROM currency-exchange-rates-fixed"))
	72	{
	73	assertTrue(rs1.next());
	74	assertEquals("Country rate is wrong", "GERMANY", rs1.getString("Country"));
	75	assertEquals("Currency rate is wrong", "Euro", rs1.getString("Currency"));
	76	assertEquals("ISO rate is wrong", "EUR", rs1.getString("ISO"));
	77	assertEquals("YESTERDY rate is wrong", "0.761645", rs1.getString("YESTERDY"));
	78	assertEquals("TODAY_ rate is wrong", "0.763246", rs1.getString("TODAY_"));
	79	assertEquals("% Change rate is wrong", "0.002102", rs1.getString("% Change"));
	80
	81	assertTrue(rs1.next());
	82	assertEquals("Country rate is wrong", "GREECE", rs1.getString(1));
	83	assertEquals("Currency rate is wrong", "Euro", rs1.getString(2));
	84	assertEquals("ISO rate is wrong", "EUR", rs1.getString(3));
	85	assertEquals("YESTERDY rate is wrong", "0.761645", rs1.getString(4));
	86	assertEquals("TODAY_ rate is wrong", "0.763246", rs1.getString(5));
	87	assertEquals("% Change rate is wrong", "0.002102", rs1.getString(6));
	88
	89	assertTrue(rs1.next());
	90	}
89	91	}
90	92
91	93	@Test

102	104	props.put("columnTypes", "String,String,String,Double,Double,Double");
103	105	props.put("fixedWidths", "1-16,17-24,25-27,35-42,43-50,51-58");
104	106
105		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
106
107		Statement stmt = conn.createStatement();
108
109		// GERMANY Euro EUR 0.7616450.7632460.002102
110		ResultSet rs1 = stmt
111		.executeQuery("SELECT * FROM currency-exchange-rates-fixed c WHERE c.Country = 'GERMANY'");
112		assertTrue(rs1.next());
113		assertEquals("ISO rate is wrong", "EUR", rs1.getString("ISO"));
114		assertEquals("YESTERDY rate is wrong", "0.761645", rs1.getString("PREV_DAY"));
115		assertEquals("TODAY_ rate is wrong", "0.763246", rs1.getString("TODAY"));
116		assertEquals("% Change rate is wrong", "0.002102", rs1.getString("PTChange"));
117
118		// HUNGARY Forint HUF 226.1222226.67130.002429
119		ResultSet rs2 = stmt
120		.executeQuery("SELECT * FROM currency-exchange-rates-fixed c WHERE c.Country = 'HUNGARY'");
121		assertTrue(rs2.next());
122		assertEquals("ISO rate is wrong", "HUF", rs2.getString("ISO"));
123		assertEquals("YESTERDY rate is wrong", "226.1222", rs2.getString("PREV_DAY"));
124		assertEquals("TODAY_ rate is wrong", "226.6713", rs2.getString("TODAY"));
125		assertEquals("% Change rate is wrong", "0.002429", rs2.getString("PTChange"));
126
127		// PERU Sol PEN 2.6618362.661836 0
128		ResultSet rs3 = stmt
129		.executeQuery("SELECT * FROM currency-exchange-rates-fixed c WHERE c.Country = 'PERU'");
130		assertTrue(rs3.next());
131		assertEquals("ISO rate is wrong", "PEN", rs3.getString("ISO"));
132		assertEquals("YESTERDY rate is wrong", "2.661836", rs3.getString("PREV_DAY"));
133		assertEquals("TODAY_ rate is wrong", "2.661836", rs3.getString("TODAY"));
134		assertEquals("% Change rate is wrong", "0.0", rs3.getString("PTChange"));
135
136		//SAUDI ARABIA Riyal SAR 3.7504133.750361-1.4E-05
137		ResultSet rs4 = stmt
138		.executeQuery("SELECT * FROM currency-exchange-rates-fixed c WHERE c.Country = 'SAUDI ARABIA'");
139		assertTrue(rs4.next());
140		assertEquals("ISO rate is wrong", "SAR", rs4.getString("ISO"));
141		assertEquals("YESTERDY rate is wrong", "3.750413", rs4.getString("PREV_DAY"));
142		assertEquals("TODAY_ rate is wrong", "3.750361", rs4.getString("TODAY"));
143		assertEquals("% Change rate is wrong", "-1.4E-5", rs4.getString("PTChange"));
	107	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
	108
	109	Statement stmt = conn.createStatement())
	110	{
	111	// GERMANY Euro EUR 0.7616450.7632460.002102
	112	try (ResultSet rs1 = stmt
	113	.executeQuery("SELECT * FROM currency-exchange-rates-fixed c WHERE c.Country = 'GERMANY'"))
	114	{
	115	assertTrue(rs1.next());
	116	assertEquals("ISO rate is wrong", "EUR", rs1.getString("ISO"));
	117	assertEquals("YESTERDY rate is wrong", "0.761645", rs1.getString("PREV_DAY"));
	118	assertEquals("TODAY_ rate is wrong", "0.763246", rs1.getString("TODAY"));
	119	assertEquals("% Change rate is wrong", "0.002102", rs1.getString("PTChange"));
	120	}
	121
	122	// HUNGARY Forint HUF 226.1222226.67130.002429
	123	try (ResultSet rs2 = stmt
	124	.executeQuery("SELECT * FROM currency-exchange-rates-fixed c WHERE c.Country = 'HUNGARY'"))
	125	{
	126	assertTrue(rs2.next());
	127	assertEquals("ISO rate is wrong", "HUF", rs2.getString("ISO"));
	128	assertEquals("YESTERDY rate is wrong", "226.1222", rs2.getString("PREV_DAY"));
	129	assertEquals("TODAY_ rate is wrong", "226.6713", rs2.getString("TODAY"));
	130	assertEquals("% Change rate is wrong", "0.002429", rs2.getString("PTChange"));
	131	}
	132
	133	// PERU Sol PEN 2.6618362.661836 0
	134	try (ResultSet rs3 = stmt
	135	.executeQuery("SELECT * FROM currency-exchange-rates-fixed c WHERE c.Country = 'PERU'"))
	136	{
	137	assertTrue(rs3.next());
	138	assertEquals("ISO rate is wrong", "PEN", rs3.getString("ISO"));
	139	assertEquals("YESTERDY rate is wrong", "2.661836", rs3.getString("PREV_DAY"));
	140	assertEquals("TODAY_ rate is wrong", "2.661836", rs3.getString("TODAY"));
	141	assertEquals("% Change rate is wrong", "0.0", rs3.getString("PTChange"));
	142	}
	143
	144	//SAUDI ARABIA Riyal SAR 3.7504133.750361-1.4E-05
	145	try (ResultSet rs4 = stmt
	146	.executeQuery("SELECT * FROM currency-exchange-rates-fixed c WHERE c.Country = 'SAUDI ARABIA'"))
	147	{
	148	assertTrue(rs4.next());
	149	assertEquals("ISO rate is wrong", "SAR", rs4.getString("ISO"));
	150	assertEquals("YESTERDY rate is wrong", "3.750413", rs4.getString("PREV_DAY"));
	151	assertEquals("TODAY_ rate is wrong", "3.750361", rs4.getString("TODAY"));
	152	assertEquals("% Change rate is wrong", "-1.4E-5", rs4.getString("PTChange"));
	153	}
	154	}
144	155	}
145	156
146	157	@Test
147	158	public void testNumericColumns() throws SQLException
148		{
	159	{
149	160	Properties props = new Properties();
150	161	props.put("fileExtension", ".txt");
151	162	props.put("columnTypes", "String,String,String,Double,Double,Double");
152	163	props.put("fixedWidths", "1-16,17-24,25-27,35-42,43-50,51-58");
153	164
154		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
155
156		Statement stmt = conn.createStatement();
157
158		//SWEDEN Krona SEK 6.76557 6.752711 -0.0019
159		//SWITZERLAND Franc CHF 0.9153470.9178320.002715
160		ResultSet rs1 = stmt.executeQuery("SELECT * FROM currency-exchange-rates-fixed " +
161		"WHERE Country='SWEDEN' OR Country='SWITZERLAND'");
162		int multiplier = 1000;
163		assertTrue(rs1.next());
164		assertEquals("TODAY_ is wrong", Math.round(6.76557 * multiplier), Math.round(rs1.getDouble("YESTERDY") * multiplier));
165		assertEquals("YESTERDY is wrong", Math.round(6.752711 * multiplier), Math.round(rs1.getDouble("TODAY_") * multiplier));
166		assertEquals("% Change is wrong", Math.round(-0.0019 * multiplier), Math.round(rs1.getDouble("% Change") * multiplier));
167
168		assertTrue(rs1.next());
169		assertEquals("TODAY_ is wrong", Math.round(0.915347 * multiplier), Math.round(rs1.getDouble("YESTERDY") * multiplier));
170		assertEquals("YESTERDY is wrong", Math.round(0.917832 * multiplier), Math.round(rs1.getDouble("TODAY_") * multiplier));
171		assertEquals("% Change is wrong", Math.round(0.002715 * multiplier), Math.round(rs1.getDouble("% Change") * multiplier));
	165	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
	166
	167	Statement stmt = conn.createStatement();
	168
	169	//SWEDEN Krona SEK 6.76557 6.752711 -0.0019
	170	//SWITZERLAND Franc CHF 0.9153470.9178320.002715
	171	ResultSet rs1 = stmt.executeQuery("SELECT * FROM currency-exchange-rates-fixed " +
	172	"WHERE Country='SWEDEN' OR Country='SWITZERLAND'"))
	173	{
	174	int multiplier = 1000;
	175	assertTrue(rs1.next());
	176	assertEquals("TODAY_ is wrong", Math.round(6.76557 * multiplier), Math.round(rs1.getDouble("YESTERDY") * multiplier));
	177	assertEquals("YESTERDY is wrong", Math.round(6.752711 * multiplier), Math.round(rs1.getDouble("TODAY_") * multiplier));
	178	assertEquals("% Change is wrong", Math.round(-0.0019 * multiplier), Math.round(rs1.getDouble("% Change") * multiplier));
	179
	180	assertTrue(rs1.next());
	181	assertEquals("TODAY_ is wrong", Math.round(0.915347 * multiplier), Math.round(rs1.getDouble("YESTERDY") * multiplier));
	182	assertEquals("YESTERDY is wrong", Math.round(0.917832 * multiplier), Math.round(rs1.getDouble("TODAY_") * multiplier));
	183	assertEquals("% Change is wrong", Math.round(0.002715 * multiplier), Math.round(rs1.getDouble("% Change") * multiplier));
	184	}
172	185	}
173	186
174	187	@Test
175	188	public void testColumnSizes() throws SQLException
176		{
	189	{
177	190	Properties props = new Properties();
178	191	props.put("fileExtension", ".txt");
179	192	props.put("columnTypes", "String,String,String,Double,Double,Double");
180	193	props.put("fixedWidths", "1-16,17-24,25-27,35-42,43-50,51-58");
181	194
182		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
183
184		Statement stmt = conn.createStatement();
185
186		ResultSet rs1 = stmt.executeQuery("SELECT Country,YESTERDY,ISO FROM currency-exchange-rates-fixed");
187
188		ResultSetMetaData meta = rs1.getMetaData();
189		assertEquals("Incorrect Column Size", 16, meta.getColumnDisplaySize(1));
190		assertEquals("Incorrect Column Size", 8, meta.getColumnDisplaySize(2));
191		assertEquals("Incorrect Column Size", 3, meta.getColumnDisplaySize(3));
	195	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
	196
	197	Statement stmt = conn.createStatement();
	198
	199	ResultSet rs1 = stmt.executeQuery("SELECT Country,YESTERDY,ISO FROM currency-exchange-rates-fixed"))
	200	{
	201	ResultSetMetaData meta = rs1.getMetaData();
	202	assertEquals("Incorrect Column Size", 16, meta.getColumnDisplaySize(1));
	203	assertEquals("Incorrect Column Size", 8, meta.getColumnDisplaySize(2));
	204	assertEquals("Incorrect Column Size", 3, meta.getColumnDisplaySize(3));
	205	}
192	206	}
193	207
194	208	@Test
195	209	public void testWidthOrder() throws SQLException
196		{
	210	{
197	211	Properties props = new Properties();
198	212	props.put("fileExtension", ".txt");
199	213	props.put("columnTypes", "String,Integer,String");
200	214	props.put("fixedWidths", "30-32,29,25-28");
201	215
202		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
203
204		Statement stmt = conn.createStatement();
205
206		ResultSet rs1 = stmt.executeQuery("SELECT * FROM flights");
207		assertTrue(rs1.next());
208		assertEquals("Column 1 is wrong", "A18", rs1.getString(1));
209		assertEquals("Column 2 is wrong", 1, rs1.getInt(2));
210		assertEquals("Column 3 is wrong", "", rs1.getString(3));
211
212		assertTrue(rs1.next());
213		assertEquals("Column 1 is wrong", "B2", rs1.getString(1));
214		assertEquals("Column 2 is wrong", 1, rs1.getInt(2));
215		assertEquals("Column 3 is wrong", "", rs1.getString(3));
216
217		assertTrue(rs1.next());
218		assertEquals("Column 1 is wrong", "D4", rs1.getString(1));
219		assertEquals("Column 2 is wrong", 2, rs1.getInt(2));
220		assertEquals("Column 3 is wrong", "", rs1.getString(3));
221
222		assertTrue(rs1.next());
223		assertEquals("Column 1 is wrong", "A22", rs1.getString(1));
224		assertEquals("Column 2 is wrong", 1, rs1.getInt(2));
225		assertEquals("Column 3 is wrong", "1320", rs1.getString(3));
	216	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
	217
	218	Statement stmt = conn.createStatement();
	219
	220	ResultSet rs1 = stmt.executeQuery("SELECT * FROM flights"))
	221	{
	222	assertTrue(rs1.next());
	223	assertEquals("Column 1 is wrong", "A18", rs1.getString(1));
	224	assertEquals("Column 2 is wrong", 1, rs1.getInt(2));
	225	assertEquals("Column 3 is wrong", "", rs1.getString(3));
	226
	227	assertTrue(rs1.next());
	228	assertEquals("Column 1 is wrong", "B2", rs1.getString(1));
	229	assertEquals("Column 2 is wrong", 1, rs1.getInt(2));
	230	assertEquals("Column 3 is wrong", "", rs1.getString(3));
	231
	232	assertTrue(rs1.next());
	233	assertEquals("Column 1 is wrong", "D4", rs1.getString(1));
	234	assertEquals("Column 2 is wrong", 2, rs1.getInt(2));
	235	assertEquals("Column 3 is wrong", "", rs1.getString(3));
	236
	237	assertTrue(rs1.next());
	238	assertEquals("Column 1 is wrong", "A22", rs1.getString(1));
	239	assertEquals("Column 2 is wrong", 1, rs1.getInt(2));
	240	assertEquals("Column 3 is wrong", "1320", rs1.getString(3));
	241	}
226	242	}
227	243
228	244	@Test

233	249	props.put("isHeaderFixedWidth", "false");
234	250	props.put("fixedWidths", "1-2,3-3,4-6,7-7");
235	251
236		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
237
238		Statement stmt = conn.createStatement();
239
240		// GERMANY Euro EUR 0.7616450.7632460.002102
241		ResultSet rs1 = stmt.executeQuery("SELECT * FROM single-char-cols-fixed");
242		assertTrue(rs1.next());
243		assertEquals("Column 1 value is wrong", "BB", rs1.getString("TwoChars"));
244		assertEquals("Column 2 value is wrong", "A", rs1.getString("OneChar"));
245		assertEquals("Column 3 value is wrong", "CCC",rs1.getString("ThreeChars"));
246		assertEquals("Column 4 value is wrong", "D", rs1.getString("YetAnotherOneChar"));
247
248		assertTrue(rs1.next());
249		assertEquals("Column 1 value is wrong", "22", rs1.getString(1));
250		assertEquals("Column 2 value is wrong", "1", rs1.getString(2));
251		assertEquals("Column 3 value is wrong", "333", rs1.getString(3));
252		assertEquals("Column 4 value is wrong", "4", rs1.getString(4));
253
254		assertTrue(rs1.next());
	252	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
	253
	254	Statement stmt = conn.createStatement();
	255
	256	// GERMANY Euro EUR 0.7616450.7632460.002102
	257	ResultSet rs1 = stmt.executeQuery("SELECT * FROM single-char-cols-fixed"))
	258	{
	259	assertTrue(rs1.next());
	260	assertEquals("Column 1 value is wrong", "BB", rs1.getString("TwoChars"));
	261	assertEquals("Column 2 value is wrong", "A", rs1.getString("OneChar"));
	262	assertEquals("Column 3 value is wrong", "CCC",rs1.getString("ThreeChars"));
	263	assertEquals("Column 4 value is wrong", "D", rs1.getString("YetAnotherOneChar"));
	264
	265	assertTrue(rs1.next());
	266	assertEquals("Column 1 value is wrong", "22", rs1.getString(1));
	267	assertEquals("Column 2 value is wrong", "1", rs1.getString(2));
	268	assertEquals("Column 3 value is wrong", "333", rs1.getString(3));
	269	assertEquals("Column 4 value is wrong", "4", rs1.getString(4));
	270
	271	assertTrue(rs1.next());
	272	}
255	273	}
256	274
257	275	@Test

265	283	props.put("isHeaderFixedWidth", "false");
266	284	props.put("fixedWidths", "1-2,3-3,4-6,7-7");
267	285
268		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
269
270		Statement stmt = conn.createStatement();
271
272		// GERMANY Euro EUR 0.7616450.7632460.002102
273		ResultSet rs1 = stmt.executeQuery("SELECT * FROM single-char-cols-fixed");
274		assertTrue(rs1.next());
275		assertEquals("Column 1 value is wrong", "BB", rs1.getString("Column1"));
276		assertEquals("Column 2 value is wrong", "A", rs1.getString("Column2"));
277		assertEquals("Column 3 value is wrong", "CCC",rs1.getString("Column3"));
278		assertEquals("Column 4 value is wrong", "D", rs1.getString("Column4"));
279
280		assertTrue(rs1.next());
281		assertEquals("Column 1 value is wrong", "22", rs1.getString(1));
282		assertEquals("Column 2 value is wrong", "1", rs1.getString(2));
283		assertEquals("Column 3 value is wrong", "333", rs1.getString(3));
284		assertEquals("Column 4 value is wrong", "4", rs1.getString(4));
285
286		assertTrue(rs1.next());
	286	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
	287
	288	Statement stmt = conn.createStatement();
	289
	290	// GERMANY Euro EUR 0.7616450.7632460.002102
	291	ResultSet rs1 = stmt.executeQuery("SELECT * FROM single-char-cols-fixed"))
	292	{
	293	assertTrue(rs1.next());
	294	assertEquals("Column 1 value is wrong", "BB", rs1.getString("Column1"));
	295	assertEquals("Column 2 value is wrong", "A", rs1.getString("Column2"));
	296	assertEquals("Column 3 value is wrong", "CCC",rs1.getString("Column3"));
	297	assertEquals("Column 4 value is wrong", "D", rs1.getString("Column4"));
	298
	299	assertTrue(rs1.next());
	300	assertEquals("Column 1 value is wrong", "22", rs1.getString(1));
	301	assertEquals("Column 2 value is wrong", "1", rs1.getString(2));
	302	assertEquals("Column 3 value is wrong", "333", rs1.getString(3));
	303	assertEquals("Column 4 value is wrong", "4", rs1.getString(4));
	304
	305	assertTrue(rs1.next());
	306	}
287	307	}
288	308	}

+404

-354

src/test/java/org/relique/jdbc/csv/TestGroupBy.java less more

62	62	{
63	63	fail("Driver is not in the CLASSPATH -> " + e);
64	64	}
65		toUTC = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
66		toUTC.setTimeZone(TimeZone.getTimeZone("UTC"));
	65	toUTC = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
	66	toUTC.setTimeZone(TimeZone.getTimeZone("UTC"));
67	67	}
68	68
69	69	@Test

75	75	props.put("fileExtension", ".txt");
76	76	props.put("commentChar", "#");
77	77	props.put("columnTypes", "Date,Integer,Integer,Integer,Integer,Double");
78		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
79
80		Statement stmt = conn.createStatement();
81
82		ResultSet results = stmt
83		.executeQuery("select TO_BLZ from transactions group by TO_BLZ");
84		assertTrue(results.next());
85		assertEquals("The TO_BLZ is wrong", 10020500, results.getInt("TO_BLZ"));
86		assertTrue(results.next());
87		assertEquals("The TO_BLZ is wrong", 10010424, results.getInt("TO_BLZ"));
88		assertTrue(results.next());
89		assertEquals("The TO_BLZ is wrong", 10020400, results.getInt("TO_BLZ"));
90		assertTrue(results.next());
91		assertEquals("The TO_BLZ is wrong", 10010010, results.getInt("TO_BLZ"));
92		assertFalse(results.next());
	78
	79	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
	80
	81	Statement stmt = conn.createStatement();
	82
	83	ResultSet results = stmt
	84	.executeQuery("select TO_BLZ from transactions group by TO_BLZ"))
	85	{
	86	assertTrue(results.next());
	87	assertEquals("The TO_BLZ is wrong", 10020500, results.getInt("TO_BLZ"));
	88	assertTrue(results.next());
	89	assertEquals("The TO_BLZ is wrong", 10010424, results.getInt("TO_BLZ"));
	90	assertTrue(results.next());
	91	assertEquals("The TO_BLZ is wrong", 10020400, results.getInt("TO_BLZ"));
	92	assertTrue(results.next());
	93	assertEquals("The TO_BLZ is wrong", 10010010, results.getInt("TO_BLZ"));
	94	assertFalse(results.next());
	95	}
93	96	}
94	97
95	98	@Test

102	105	props.put("commentChar", "#");
103	106	props.put("columnTypes", "Date,Integer,Integer,Integer,Integer,Double");
104	107	props.put("dateFormat", "dd-mm-yyyy");
105		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
106
107		Statement stmt = conn.createStatement();
108
109		ResultSet results = stmt
110		.executeQuery("select TRANS_DATE, TO_BLZ from transactions group by TRANS_DATE, TO_BLZ");
111		assertTrue(results.next());
112		assertEquals("The TRANS_DATE is wrong", Date.valueOf("2011-10-19"), results.getDate("TRANS_DATE"));
113		assertEquals("The TO_BLZ is wrong", 10020500, results.getInt("TO_BLZ"));
114		assertTrue(results.next());
115		assertEquals("The TRANS_DATE is wrong", Date.valueOf("2011-10-21"), results.getDate("TRANS_DATE"));
116		assertEquals("The TO_BLZ is wrong", 10020500, results.getInt("TO_BLZ"));
117		assertTrue(results.next());
118		assertEquals("The TRANS_DATE is wrong", Date.valueOf("2011-10-21"), results.getDate("TRANS_DATE"));
119		assertEquals("The TO_BLZ is wrong", 10010424, results.getInt("TO_BLZ"));
120		assertTrue(results.next());
121		assertEquals("The TRANS_DATE is wrong", Date.valueOf("2011-10-24"), results.getDate("TRANS_DATE"));
122		assertEquals("The TO_BLZ is wrong", 10020500, results.getInt("TO_BLZ"));
123		assertTrue(results.next());
124		assertEquals("The TRANS_DATE is wrong", Date.valueOf("2011-10-27"), results.getDate("TRANS_DATE"));
125		assertEquals("The TO_BLZ is wrong", 10020500, results.getInt("TO_BLZ"));
126		assertTrue(results.next());
127		assertEquals("The TRANS_DATE is wrong", Date.valueOf("2011-10-28"), results.getDate("TRANS_DATE"));
128		assertEquals("The TO_BLZ is wrong", 10020400, results.getInt("TO_BLZ"));
129		assertTrue(results.next());
130		assertEquals("The TRANS_DATE is wrong", Date.valueOf("2011-10-31"), results.getDate("TRANS_DATE"));
131		assertEquals("The TO_BLZ is wrong", 10010010, results.getInt("TO_BLZ"));
132		assertFalse(results.next());
	108
	109	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
	110
	111	Statement stmt = conn.createStatement();
	112
	113	ResultSet results = stmt
	114	.executeQuery("select TRANS_DATE, TO_BLZ from transactions group by TRANS_DATE, TO_BLZ"))
	115	{
	116	assertTrue(results.next());
	117	assertEquals("The TRANS_DATE is wrong", Date.valueOf("2011-10-19"), results.getDate("TRANS_DATE"));
	118	assertEquals("The TO_BLZ is wrong", 10020500, results.getInt("TO_BLZ"));
	119	assertTrue(results.next());
	120	assertEquals("The TRANS_DATE is wrong", Date.valueOf("2011-10-21"), results.getDate("TRANS_DATE"));
	121	assertEquals("The TO_BLZ is wrong", 10020500, results.getInt("TO_BLZ"));
	122	assertTrue(results.next());
	123	assertEquals("The TRANS_DATE is wrong", Date.valueOf("2011-10-21"), results.getDate("TRANS_DATE"));
	124	assertEquals("The TO_BLZ is wrong", 10010424, results.getInt("TO_BLZ"));
	125	assertTrue(results.next());
	126	assertEquals("The TRANS_DATE is wrong", Date.valueOf("2011-10-24"), results.getDate("TRANS_DATE"));
	127	assertEquals("The TO_BLZ is wrong", 10020500, results.getInt("TO_BLZ"));
	128	assertTrue(results.next());
	129	assertEquals("The TRANS_DATE is wrong", Date.valueOf("2011-10-27"), results.getDate("TRANS_DATE"));
	130	assertEquals("The TO_BLZ is wrong", 10020500, results.getInt("TO_BLZ"));
	131	assertTrue(results.next());
	132	assertEquals("The TRANS_DATE is wrong", Date.valueOf("2011-10-28"), results.getDate("TRANS_DATE"));
	133	assertEquals("The TO_BLZ is wrong", 10020400, results.getInt("TO_BLZ"));
	134	assertTrue(results.next());
	135	assertEquals("The TRANS_DATE is wrong", Date.valueOf("2011-10-31"), results.getDate("TRANS_DATE"));
	136	assertEquals("The TO_BLZ is wrong", 10010010, results.getInt("TO_BLZ"));
	137	assertFalse(results.next());
	138	}
133	139	}
134	140
135	141	@Test

137	143	{
138	144	Properties props = new Properties();
139	145	props.put("fileExtension", ".txt");
140		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
141
142		Statement stmt = conn.createStatement();
143
144		ResultSet results = stmt.executeQuery("select ID from empty-2 GROUP BY ID");
145		assertFalse(results.next());
	146
	147	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
	148
	149	Statement stmt = conn.createStatement();
	150
	151	ResultSet results = stmt.executeQuery("select ID from empty-2 GROUP BY ID"))
	152	{
	153	assertFalse(results.next());
	154	}
146	155	}
147	156
148	157	@Test
149	158	public void testGroupByAllDifferent() throws SQLException
150	159	{
151	160	Properties props = new Properties();
152		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
153
154		Statement stmt = conn.createStatement();
155
156		ResultSet results = stmt.executeQuery("select ID from sample4 GROUP BY ID");
157		assertTrue(results.next());
158		assertEquals("The ID is wrong", "01", results.getString("ID"));
159		assertTrue(results.next());
160		assertEquals("The ID is wrong", "02", results.getString("ID"));
161		assertTrue(results.next());
162		assertEquals("The ID is wrong", "03", results.getString("ID"));
163		assertTrue(results.next());
164		assertEquals("The ID is wrong", "04", results.getString("ID"));
165		assertFalse(results.next());
	161
	162	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
	163
	164	Statement stmt = conn.createStatement();
	165
	166	ResultSet results = stmt.executeQuery("select ID from sample4 GROUP BY ID"))
	167	{
	168	assertTrue(results.next());
	169	assertEquals("The ID is wrong", "01", results.getString("ID"));
	170	assertTrue(results.next());
	171	assertEquals("The ID is wrong", "02", results.getString("ID"));
	172	assertTrue(results.next());
	173	assertEquals("The ID is wrong", "03", results.getString("ID"));
	174	assertTrue(results.next());
	175	assertEquals("The ID is wrong", "04", results.getString("ID"));
	176	assertFalse(results.next());
	177	}
166	178	}
167	179
168	180	@Test

170	182	{
171	183	Properties props = new Properties();
172	184	props.put("columnTypes", "Int,String,String,Timestamp");
173		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
174
175		Statement stmt = conn.createStatement();
176
177		ResultSet results = stmt.executeQuery("select Job from sample5 WHERE ID >= 5 GROUP BY Job");
178		assertTrue(results.next());
179		assertEquals("The Job is wrong", "Piloto", results.getString("Job"));
180		assertTrue(results.next());
181		assertEquals("The Job is wrong", "Office Manager", results.getString("Job"));
182		assertTrue(results.next());
183		assertEquals("The Job is wrong", "Office Employee", results.getString("Job"));
184		assertFalse(results.next());
	185
	186	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
	187
	188	Statement stmt = conn.createStatement();
	189
	190	ResultSet results = stmt.executeQuery("select Job from sample5 WHERE ID >= 5 GROUP BY Job"))
	191	{
	192	assertTrue(results.next());
	193	assertEquals("The Job is wrong", "Piloto", results.getString("Job"));
	194	assertTrue(results.next());
	195	assertEquals("The Job is wrong", "Office Manager", results.getString("Job"));
	196	assertTrue(results.next());
	197	assertEquals("The Job is wrong", "Office Employee", results.getString("Job"));
	198	assertFalse(results.next());
	199	}
185	200	}
186	201
187	202	@Test
188	203	public void testGroupByOrderBy() throws SQLException
189	204	{
190	205	Properties props = new Properties();
191		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
192
193		Statement stmt = conn.createStatement();
194
195		ResultSet results = stmt.executeQuery("select Job from sample4 GROUP BY Job ORDER BY Job");
196		assertTrue(results.next());
197		assertEquals("The Job is wrong", "Finance Manager", results.getString("Job"));
198		assertTrue(results.next());
199		assertEquals("The Job is wrong", "Project Manager", results.getString("Job"));
200		assertFalse(results.next());
	206
	207	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
	208
	209	Statement stmt = conn.createStatement();
	210
	211	ResultSet results = stmt.executeQuery("select Job from sample4 GROUP BY Job ORDER BY Job"))
	212	{
	213	assertTrue(results.next());
	214	assertEquals("The Job is wrong", "Finance Manager", results.getString("Job"));
	215	assertTrue(results.next());
	216	assertEquals("The Job is wrong", "Project Manager", results.getString("Job"));
	217	assertFalse(results.next());
	218	}
201	219	}
202	220
203	221	@Test

209	227	props.put("fileExtension", ".txt");
210	228	props.put("commentChar", "#");
211	229	props.put("columnTypes", "Date,Integer,Integer,Integer,Integer,Double");
212		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
213
214		Statement stmt = conn.createStatement();
215
216		ResultSet results = stmt
217		.executeQuery("select TO_BLZ, COUNT(TO_BLZ) AS N from transactions group by TO_BLZ");
218		assertTrue(results.next());
219		assertEquals("The TO_BLZ is wrong", 10020500, results.getInt("TO_BLZ"));
220		assertEquals("The COUNT is wrong", 5, results.getInt("N"));
221		assertTrue(results.next());
222		assertEquals("The TO_BLZ is wrong", 10010424, results.getInt("TO_BLZ"));
223		assertEquals("The COUNT is wrong", 2, results.getInt("N"));
224		assertTrue(results.next());
225		assertEquals("The TO_BLZ is wrong", 10020400, results.getInt("TO_BLZ"));
226		assertEquals("The COUNT is wrong", 1, results.getInt("N"));
227		assertTrue(results.next());
228		assertEquals("The TO_BLZ is wrong", 10010010, results.getInt("TO_BLZ"));
229		assertEquals("The COUNT is wrong", 1, results.getInt("N"));
230		assertFalse(results.next());
	230
	231	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
	232
	233	Statement stmt = conn.createStatement();
	234
	235	ResultSet results = stmt
	236	.executeQuery("select TO_BLZ, COUNT(TO_BLZ) AS N from transactions group by TO_BLZ"))
	237	{
	238	assertTrue(results.next());
	239	assertEquals("The TO_BLZ is wrong", 10020500, results.getInt("TO_BLZ"));
	240	assertEquals("The COUNT is wrong", 5, results.getInt("N"));
	241	assertTrue(results.next());
	242	assertEquals("The TO_BLZ is wrong", 10010424, results.getInt("TO_BLZ"));
	243	assertEquals("The COUNT is wrong", 2, results.getInt("N"));
	244	assertTrue(results.next());
	245	assertEquals("The TO_BLZ is wrong", 10020400, results.getInt("TO_BLZ"));
	246	assertEquals("The COUNT is wrong", 1, results.getInt("N"));
	247	assertTrue(results.next());
	248	assertEquals("The TO_BLZ is wrong", 10010010, results.getInt("TO_BLZ"));
	249	assertEquals("The COUNT is wrong", 1, results.getInt("N"));
	250	assertFalse(results.next());
	251	}
231	252	}
232	253
233	254	@Test

235	256	{
236	257	Properties props = new Properties();
237	258	props.put("columnTypes", "String,Integer");
238		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
239
240		Statement stmt = conn.createStatement();
241
242		ResultSet results = stmt.executeQuery("select NAME, count(*) from scores group by NAME");
243		assertTrue(results.next());
244		assertEquals("The NAME is wrong", "Daniel", results.getString(1));
245		assertEquals("The COUNT is wrong", 3, results.getInt(2));
246		assertTrue(results.next());
247		assertEquals("The NAME is wrong", "Mark", results.getString(1));
248		assertEquals("The COUNT is wrong", 3, results.getInt(2));
249		assertTrue(results.next());
250		assertEquals("The NAME is wrong", "Maria", results.getString(1));
251		assertEquals("The COUNT is wrong", 3, results.getInt(2));
	259
	260	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
	261
	262	Statement stmt = conn.createStatement();
	263
	264	ResultSet results = stmt.executeQuery("select NAME, count(*) from scores group by NAME"))
	265	{
	266	assertTrue(results.next());
	267	assertEquals("The NAME is wrong", "Daniel", results.getString(1));
	268	assertEquals("The COUNT is wrong", 3, results.getInt(2));
	269	assertTrue(results.next());
	270	assertEquals("The NAME is wrong", "Mark", results.getString(1));
	271	assertEquals("The COUNT is wrong", 3, results.getInt(2));
	272	assertTrue(results.next());
	273	assertEquals("The NAME is wrong", "Maria", results.getString(1));
	274	assertEquals("The COUNT is wrong", 3, results.getInt(2));
	275	}
252	276	}
253	277
254	278	@Test
255	279	public void testGroupByCountNull() throws SQLException
256	280	{
257	281	Properties props = new Properties();
258		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
259
260		Statement stmt = conn.createStatement();
261
262		ResultSet results = stmt.executeQuery("select NAME, COUNT(NULLIF(SCORE, 'NA')) FROM scores GROUP BY NAME");
263		assertTrue(results.next());
264		assertEquals("The NAME is wrong", "Daniel", results.getString(1));
265		assertEquals("The COUNT is wrong", 2, results.getInt(2));
266		assertTrue(results.next());
267		assertEquals("The NAME is wrong", "Mark", results.getString(1));
268		assertEquals("The COUNT is wrong", 3, results.getInt(2));
269		assertTrue(results.next());
270		assertEquals("The NAME is wrong", "Maria", results.getString(1));
271		assertEquals("The COUNT is wrong", 1, results.getInt(2));
272		assertFalse(results.next());
	282
	283	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
	284
	285	Statement stmt = conn.createStatement();
	286
	287	ResultSet results = stmt.executeQuery("select NAME, COUNT(NULLIF(SCORE, 'NA')) FROM scores GROUP BY NAME"))
	288	{
	289	assertTrue(results.next());
	290	assertEquals("The NAME is wrong", "Daniel", results.getString(1));
	291	assertEquals("The COUNT is wrong", 2, results.getInt(2));
	292	assertTrue(results.next());
	293	assertEquals("The NAME is wrong", "Mark", results.getString(1));
	294	assertEquals("The COUNT is wrong", 3, results.getInt(2));
	295	assertTrue(results.next());
	296	assertEquals("The NAME is wrong", "Maria", results.getString(1));
	297	assertEquals("The COUNT is wrong", 1, results.getInt(2));
	298	assertFalse(results.next());
	299	}
273	300	}
274	301
275	302	/**

289	316	props.put("fileExtension", ".txt");
290	317	props.put("commentChar", "#");
291	318	props.put("columnTypes", "Date,Integer,Integer,Integer,Integer,Double");
292		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
293
294		Statement stmt = conn.createStatement();
295
296		ResultSet results = stmt
297		.executeQuery("select TO_BLZ, MIN(AMOUNT) AS MIN_AMOUNT, MAX(AMOUNT) AS MAX_AMOUNT from transactions group by TO_BLZ");
298		assertTrue(results.next());
299		assertEquals("The TO_BLZ is wrong", 10020500, results.getInt("TO_BLZ"));
300		assertTrue("The MIN_AMOUNT is wrong", fuzzyEquals(21.23, results.getDouble("MIN_AMOUNT")));
301		assertTrue("The MAX_AMOUNT is wrong", fuzzyEquals(250.00, results.getDouble("MAX_AMOUNT")));
302		assertTrue(results.next());
303		assertEquals("The TO_BLZ is wrong", 10010424, results.getInt("TO_BLZ"));
304		assertTrue("The MIN_AMOUNT is wrong", fuzzyEquals(460.00, results.getDouble("MIN_AMOUNT")));
305		assertTrue("The MAX_AMOUNT is wrong", fuzzyEquals(999.00, results.getDouble("MAX_AMOUNT")));
306		assertTrue(results.next());
307		assertEquals("The TO_BLZ is wrong", 10020400, results.getInt("TO_BLZ"));
308		assertTrue("The MIN_AMOUNT is wrong", fuzzyEquals(1012.74, results.getDouble("MIN_AMOUNT")));
309		assertTrue("The MAX_AMOUNT is wrong", fuzzyEquals(1012.74, results.getDouble("MAX_AMOUNT")));
310		assertTrue(results.next());
311		assertEquals("The TO_BLZ is wrong", 10010010, results.getInt("TO_BLZ"));
312		assertTrue("The MIN_AMOUNT is wrong", fuzzyEquals(7.23, results.getDouble("MIN_AMOUNT")));
313		assertTrue("The MAX_AMOUNT is wrong", fuzzyEquals(7.23, results.getDouble("MAX_AMOUNT")));
314		assertFalse(results.next());
	319
	320	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
	321
	322	Statement stmt = conn.createStatement();
	323
	324	ResultSet results = stmt
	325	.executeQuery("select TO_BLZ, MIN(AMOUNT) AS MIN_AMOUNT, MAX(AMOUNT) AS MAX_AMOUNT from transactions group by TO_BLZ"))
	326	{
	327	assertTrue(results.next());
	328	assertEquals("The TO_BLZ is wrong", 10020500, results.getInt("TO_BLZ"));
	329	assertTrue("The MIN_AMOUNT is wrong", fuzzyEquals(21.23, results.getDouble("MIN_AMOUNT")));
	330	assertTrue("The MAX_AMOUNT is wrong", fuzzyEquals(250.00, results.getDouble("MAX_AMOUNT")));
	331	assertTrue(results.next());
	332	assertEquals("The TO_BLZ is wrong", 10010424, results.getInt("TO_BLZ"));
	333	assertTrue("The MIN_AMOUNT is wrong", fuzzyEquals(460.00, results.getDouble("MIN_AMOUNT")));
	334	assertTrue("The MAX_AMOUNT is wrong", fuzzyEquals(999.00, results.getDouble("MAX_AMOUNT")));
	335	assertTrue(results.next());
	336	assertEquals("The TO_BLZ is wrong", 10020400, results.getInt("TO_BLZ"));
	337	assertTrue("The MIN_AMOUNT is wrong", fuzzyEquals(1012.74, results.getDouble("MIN_AMOUNT")));
	338	assertTrue("The MAX_AMOUNT is wrong", fuzzyEquals(1012.74, results.getDouble("MAX_AMOUNT")));
	339	assertTrue(results.next());
	340	assertEquals("The TO_BLZ is wrong", 10010010, results.getInt("TO_BLZ"));
	341	assertTrue("The MIN_AMOUNT is wrong", fuzzyEquals(7.23, results.getDouble("MIN_AMOUNT")));
	342	assertTrue("The MAX_AMOUNT is wrong", fuzzyEquals(7.23, results.getDouble("MAX_AMOUNT")));
	343	assertFalse(results.next());
	344	}
315	345	}
316	346
317	347	@Test
318	348	public void testGroupByStringAgg() throws SQLException
319	349	{
320		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath);
321
322		Statement stmt = conn.createStatement();
323
324		ResultSet results = stmt.executeQuery("select Job, string_agg(Name, ';') from sample4 GROUP BY Job");
325		assertTrue(results.next());
326		assertEquals("The Job is wrong", "Project Manager", results.getString(1));
327		assertEquals("The string_agg is wrong", "Juan Pablo Morales;Mauricio Hernandez;Felipe Grajales", results.getString(2));
328		assertTrue(results.next());
329		assertEquals("The Job is wrong", "Finance Manager", results.getString(1));
330		assertEquals("The string_agg is wrong", "Maria Cristina Lucero", results.getString(2));
331		assertFalse(results.next());
	350	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath);
	351
	352	Statement stmt = conn.createStatement();
	353
	354	ResultSet results = stmt.executeQuery("select Job, string_agg(Name, ';') from sample4 GROUP BY Job"))
	355	{
	356	assertTrue(results.next());
	357	assertEquals("The Job is wrong", "Project Manager", results.getString(1));
	358	assertEquals("The string_agg is wrong", "Juan Pablo Morales;Mauricio Hernandez;Felipe Grajales", results.getString(2));
	359	assertTrue(results.next());
	360	assertEquals("The Job is wrong", "Finance Manager", results.getString(1));
	361	assertEquals("The string_agg is wrong", "Maria Cristina Lucero", results.getString(2));
	362	assertFalse(results.next());
	363	}
332	364	}
333	365
334	366	@Test
335	367	public void testGroupByOrderByCount() throws SQLException
336	368	{
337	369	Properties props = new Properties();
338		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
339
340		Statement stmt = conn.createStatement();
341
342		ResultSet results = stmt.executeQuery("select Job, COUNT(Job) C from sample4 GROUP BY Job ORDER BY C DESC");
343		assertTrue(results.next());
344		assertEquals("The Job is wrong", "Project Manager", results.getString("Job"));
345		assertEquals("The COUNT is wrong", 3, results.getInt("C"));
346		assertTrue(results.next());
347		assertEquals("The Job is wrong", "Finance Manager", results.getString("Job"));
348		assertEquals("The COUNT is wrong", 1, results.getInt("C"));
349		assertFalse(results.next());
	370
	371	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
	372
	373	Statement stmt = conn.createStatement();
	374
	375	ResultSet results = stmt.executeQuery("select Job, COUNT(Job) C from sample4 GROUP BY Job ORDER BY C DESC"))
	376	{
	377	assertTrue(results.next());
	378	assertEquals("The Job is wrong", "Project Manager", results.getString("Job"));
	379	assertEquals("The COUNT is wrong", 3, results.getInt("C"));
	380	assertTrue(results.next());
	381	assertEquals("The Job is wrong", "Finance Manager", results.getString("Job"));
	382	assertEquals("The COUNT is wrong", 1, results.getInt("C"));
	383	assertFalse(results.next());
	384	}
350	385	}
351	386
352	387	@Test
353	388	public void testGroupByColumnNumber() throws SQLException
354	389	{
355	390	Properties props = new Properties();
356		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
357
358		Statement stmt = conn.createStatement();
359
360		ResultSet results = stmt.executeQuery("select Job from sample4 GROUP BY 1");
361		assertTrue(results.next());
362		assertEquals("The Job is wrong", "Project Manager", results.getString("Job"));
363		assertTrue(results.next());
364		assertEquals("The Job is wrong", "Finance Manager", results.getString("Job"));
365		assertFalse(results.next());
	391
	392	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
	393
	394	Statement stmt = conn.createStatement();
	395
	396	ResultSet results = stmt.executeQuery("select Job from sample4 GROUP BY 1"))
	397	{
	398	assertTrue(results.next());
	399	assertEquals("The Job is wrong", "Project Manager", results.getString("Job"));
	400	assertTrue(results.next());
	401	assertEquals("The Job is wrong", "Finance Manager", results.getString("Job"));
	402	assertFalse(results.next());
	403	}
366	404	}
367	405
368	406	@Test
369	407	public void testGroupByTableAlias() throws SQLException
370	408	{
371	409	Properties props = new Properties();
372		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
373
374		Statement stmt = conn.createStatement();
375
376		ResultSet results = stmt.executeQuery("select Job from sample4 T GROUP BY T.Job");
377		assertTrue(results.next());
378		assertEquals("The Job is wrong", "Project Manager", results.getString("Job"));
379		assertTrue(results.next());
380		assertEquals("The Job is wrong", "Finance Manager", results.getString("Job"));
381		assertFalse(results.next());
	410
	411	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
	412
	413	Statement stmt = conn.createStatement();
	414
	415	ResultSet results = stmt.executeQuery("select Job from sample4 T GROUP BY T.Job"))
	416	{
	417	assertTrue(results.next());
	418	assertEquals("The Job is wrong", "Project Manager", results.getString("Job"));
	419	assertTrue(results.next());
	420	assertEquals("The Job is wrong", "Finance Manager", results.getString("Job"));
	421	assertFalse(results.next());
	422	}
382	423	}
383	424
384	425	@Test

391	432	props.put("commentChar", "#");
392	433	props.put("columnTypes", "Date,Integer,Integer,Integer,Integer,Double");
393	434	props.put("dateFormat", "dd-mm-yyyy");
394		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
395
396		Statement stmt = conn.createStatement();
397
398		ResultSet results = stmt
399		.executeQuery("select FROM_ACCT + '/' + FROM_BLZ as KEY from transactions group by KEY");
400		assertTrue(results.next());
401		assertEquals("The KEY is wrong", "3670345/10010010", results.getString("KEY"));
402		assertTrue(results.next());
403		assertEquals("The KEY is wrong", "97540210/10020500", results.getString("KEY"));
404		assertTrue(results.next());
405		assertEquals("The KEY is wrong", "58340576/10010010", results.getString("KEY"));
406		assertTrue(results.next());
407		assertEquals("The KEY is wrong", "2340529/10020200", results.getString("KEY"));
408		assertFalse(results.next());
	435
	436	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
	437
	438	Statement stmt = conn.createStatement();
	439
	440	ResultSet results = stmt
	441	.executeQuery("select FROM_ACCT + '/' + FROM_BLZ as KEY from transactions group by KEY"))
	442	{
	443	assertTrue(results.next());
	444	assertEquals("The KEY is wrong", "3670345/10010010", results.getString("KEY"));
	445	assertTrue(results.next());
	446	assertEquals("The KEY is wrong", "97540210/10020500", results.getString("KEY"));
	447	assertTrue(results.next());
	448	assertEquals("The KEY is wrong", "58340576/10010010", results.getString("KEY"));
	449	assertTrue(results.next());
	450	assertEquals("The KEY is wrong", "2340529/10020200", results.getString("KEY"));
	451	assertFalse(results.next());
	452	}
409	453	}
410	454
411	455	@Test
412	456	public void testGroupByWithLiteral() throws SQLException
413	457	{
414	458	Properties props = new Properties();
415		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
416
417		Statement stmt = conn.createStatement();
418
419		ResultSet results = stmt.executeQuery("select Job + '/' C1, 7 C2 from sample4 GROUP BY Job");
420		assertTrue(results.next());
421		assertEquals("The C1 is wrong", "Project Manager/", results.getString("C1"));
422		assertEquals("The C2 is wrong", "7", results.getString("C2"));
423		assertTrue(results.next());
424		assertEquals("The C1 is wrong", "Finance Manager/", results.getString("C1"));
425		assertEquals("The C2 is wrong", "7", results.getString("C2"));
426		assertFalse(results.next());
	459
	460	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
	461
	462	Statement stmt = conn.createStatement();
	463
	464	ResultSet results = stmt.executeQuery("select Job + '/' C1, 7 C2 from sample4 GROUP BY Job"))
	465	{
	466	assertTrue(results.next());
	467	assertEquals("The C1 is wrong", "Project Manager/", results.getString("C1"));
	468	assertEquals("The C2 is wrong", "7", results.getString("C2"));
	469	assertTrue(results.next());
	470	assertEquals("The C1 is wrong", "Finance Manager/", results.getString("C1"));
	471	assertEquals("The C2 is wrong", "7", results.getString("C2"));
	472	assertFalse(results.next());
	473	}
427	474	}
428	475
429	476	@Test
430	477	public void testGroupByWithBadColumnName() throws SQLException
431		{
432		try
433		{
434		Properties props = new Properties();
435		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
436
437		Statement stmt = conn.createStatement();
438
439		stmt.executeQuery("SELECT Id FROM sample group by XXXX");
	478	{
	479	Properties props = new Properties();
	480
	481	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
	482
	483	Statement stmt = conn.createStatement();
	484	ResultSet results = stmt.executeQuery("SELECT Id FROM sample group by XXXX"))
	485	{
440	486	fail("Should raise a java.sqlSQLException");
441	487	}
442	488	catch (SQLException e)

447	493
448	494	@Test
449	495	public void testSelectUngroupedColumn() throws SQLException
450		{
451		try
452		{
453		Properties props = new Properties();
454		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
455
456		Statement stmt = conn.createStatement();
457
458		stmt.executeQuery("SELECT Id FROM sample4 group by Job");
	496	{
	497	Properties props = new Properties();
	498
	499	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
	500
	501	Statement stmt = conn.createStatement();
	502	ResultSet results = stmt.executeQuery("SELECT Id FROM sample4 group by Job"))
	503	{
459	504	fail("Should raise a java.sqlSQLException");
460	505	}
461	506	catch (SQLException e)

466	511
467	512	@Test
468	513	public void testOrderByUngroupedColumn() throws SQLException
469		{
470		try
471		{
472		Properties props = new Properties();
473		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
474
475		Statement stmt = conn.createStatement();
476
477		stmt.executeQuery("SELECT Job FROM sample4 group by Job order by Id");
	514	{
	515	Properties props = new Properties();
	516
	517	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
	518
	519	Statement stmt = conn.createStatement();
	520	ResultSet results = stmt.executeQuery("SELECT Job FROM sample4 group by Job order by Id"))
	521	{
478	522	fail("Should raise a java.sqlSQLException");
479	523	}
480	524	catch (SQLException e)

492	536	props.put("fileExtension", ".txt");
493	537	props.put("commentChar", "#");
494	538	props.put("columnTypes", "Date,Integer,Integer,Integer,Integer,Double");
495		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
496
497		Statement stmt = conn.createStatement();
498
499		ResultSet results = stmt
500		.executeQuery("select FROM_BLZ from transactions group by FROM_BLZ having FROM_BLZ > 10020000");
501		assertTrue(results.next());
502		assertEquals("The FROM_BLZ is wrong", 10020500, results.getInt("FROM_BLZ"));
503		assertTrue(results.next());
504		assertEquals("The FROM_BLZ is wrong", 10020200, results.getInt("FROM_BLZ"));
505		assertFalse(results.next());
	539
	540	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
	541
	542	Statement stmt = conn.createStatement();
	543
	544	ResultSet results = stmt
	545	.executeQuery("select FROM_BLZ from transactions group by FROM_BLZ having FROM_BLZ > 10020000"))
	546	{
	547	assertTrue(results.next());
	548	assertEquals("The FROM_BLZ is wrong", 10020500, results.getInt("FROM_BLZ"));
	549	assertTrue(results.next());
	550	assertEquals("The FROM_BLZ is wrong", 10020200, results.getInt("FROM_BLZ"));
	551	assertFalse(results.next());
	552	}
506	553	}
507	554
508	555	@Test
509	556	public void testHavingCount() throws SQLException
510	557	{
511	558	Properties props = new Properties();
512		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
513
514		Statement stmt = conn.createStatement();
515
516		ResultSet results = stmt
517		.executeQuery("select Job from sample5 group by Job having COUNT(Job) = 1");
518		assertTrue(results.next());
519		assertEquals("The Job is wrong", "Piloto", results.getString("Job"));
520		assertTrue(results.next());
521		assertEquals("The Job is wrong", "Finance Manager", results.getString("Job"));
522		assertTrue(results.next());
523		assertEquals("The Job is wrong", "Office Manager", results.getString("Job"));
524		assertFalse(results.next());
	559
	560	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
	561
	562	Statement stmt = conn.createStatement();
	563
	564	ResultSet results = stmt
	565	.executeQuery("select Job from sample5 group by Job having COUNT(Job) = 1"))
	566	{
	567	assertTrue(results.next());
	568	assertEquals("The Job is wrong", "Piloto", results.getString("Job"));
	569	assertTrue(results.next());
	570	assertEquals("The Job is wrong", "Finance Manager", results.getString("Job"));
	571	assertTrue(results.next());
	572	assertEquals("The Job is wrong", "Office Manager", results.getString("Job"));
	573	assertFalse(results.next());
	574	}
525	575	}
526	576
527	577	@Test
528	578	public void testSelectAndHavingCount() throws SQLException
529	579	{
530	580	Properties props = new Properties();
531		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
532
533		Statement stmt = conn.createStatement();
534
535		ResultSet results = stmt
536		.executeQuery("select Job, COUNT(Job) from sample5 group by Job having COUNT(Job) > 1");
537		assertTrue(results.next());
538		assertEquals("The Job is wrong", "Project Manager", results.getString("Job"));
539		assertEquals("The COUNT(Job) is wrong", 3, results.getInt(2));
540		assertTrue(results.next());
541		assertEquals("The Job is wrong", "Office Employee", results.getString("Job"));
542		assertEquals("The COUNT(Job) is wrong", 4, results.getInt(2));
543		assertFalse(results.next());
	581
	582	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
	583
	584	Statement stmt = conn.createStatement();
	585
	586	ResultSet results = stmt
	587	.executeQuery("select Job, COUNT(Job) from sample5 group by Job having COUNT(Job) > 1"))
	588	{
	589	assertTrue(results.next());
	590	assertEquals("The Job is wrong", "Project Manager", results.getString("Job"));
	591	assertEquals("The COUNT(Job) is wrong", 3, results.getInt(2));
	592	assertTrue(results.next());
	593	assertEquals("The Job is wrong", "Office Employee", results.getString("Job"));
	594	assertEquals("The COUNT(Job) is wrong", 4, results.getInt(2));
	595	assertFalse(results.next());
	596	}
544	597	}
545	598
546	599	@Test
547	600	public void testHavingWithBadColumnName() throws SQLException
548		{
549		try
550		{
551		Properties props = new Properties();
552		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
553
554		Statement stmt = conn.createStatement();
555
556		stmt.executeQuery("SELECT Id FROM sample group by Id HAVING XXXX = 1");
	601	{
	602	Properties props = new Properties();
	603
	604	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
	605
	606	Statement stmt = conn.createStatement();
	607	ResultSet results = stmt.executeQuery("SELECT Id FROM sample group by Id HAVING XXXX = 1"))
	608	{
557	609	fail("Should raise a java.sqlSQLException");
558	610	}
559	611	catch (SQLException e)

564	616
565	617	@Test
566	618	public void testHavingUngroupedColumn() throws SQLException
567		{
568		try
569		{
570		Properties props = new Properties();
571		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
572
573		Statement stmt = conn.createStatement();
574
575		stmt.executeQuery("SELECT Id FROM sample group by Id HAVING Name = 'foo'");
	619	{
	620	Properties props = new Properties();
	621
	622	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
	623
	624	Statement stmt = conn.createStatement();
	625
	626	ResultSet results = stmt.executeQuery("SELECT Id FROM sample group by Id HAVING Name = 'foo'"))
	627	{
576	628	fail("Should raise a java.sqlSQLException");
577	629	}
578	630	catch (SQLException e)

590	642	props.put("fileExtension", ".txt");
591	643	props.put("commentChar", "#");
592	644	props.put("columnTypes", "Date,Integer,Integer,Integer,Integer,Double");
593		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
594
595		Statement stmt = conn.createStatement();
596
597		ResultSet results = stmt.executeQuery("select FROM_BLZ, count(distinct FROM_ACCT) from transactions group by FROM_BLZ order by FROM_BLZ");
598		assertTrue(results.next());
599		assertEquals("Incorrect FROM_BLZ", "10010010", results.getString(1));
600		assertEquals("Incorrect count FROM_ACCT", 2, results.getInt(2));
601		assertTrue(results.next());
602		assertEquals("Incorrect FROM_BLZ", "10020200", results.getString(1));
603		assertEquals("Incorrect count FROM_ACCT", 1, results.getInt(2));
604		assertTrue(results.next());
605		assertEquals("Incorrect FROM_BLZ", "10020500", results.getString(1));
606		assertEquals("Incorrect count FROM_ACCT", 1, results.getInt(2));
607		assertFalse(results.next());
608
609		results.close();
610		stmt.close();
611		conn.close();
612		}
613
	645
	646	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
	647
	648	Statement stmt = conn.createStatement();
	649
	650	ResultSet results = stmt.executeQuery("select FROM_BLZ, count(distinct FROM_ACCT) from transactions group by FROM_BLZ order by FROM_BLZ"))
	651	{
	652	assertTrue(results.next());
	653	assertEquals("Incorrect FROM_BLZ", "10010010", results.getString(1));
	654	assertEquals("Incorrect count FROM_ACCT", 2, results.getInt(2));
	655	assertTrue(results.next());
	656	assertEquals("Incorrect FROM_BLZ", "10020200", results.getString(1));
	657	assertEquals("Incorrect count FROM_ACCT", 1, results.getInt(2));
	658	assertTrue(results.next());
	659	assertEquals("Incorrect FROM_BLZ", "10020500", results.getString(1));
	660	assertEquals("Incorrect count FROM_ACCT", 1, results.getInt(2));
	661	assertFalse(results.next());
	662	}
	663	}
	664
614	665	@Test
615	666	public void testGroupBySumAvgDistinct() throws SQLException
616	667	{
617	668	Properties props = new Properties();
618	669	props.put("columnTypes", "Int,Int,Int,Date,Time");
619	670	props.put("dateFormat", "M/D/YYYY");
620		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
621
622		Statement stmt = conn.createStatement();
623
624		ResultSet results = stmt.executeQuery("select CampaignNo, sum(distinct PurchaseCt), round(avg(distinct PurchaseCt)*10) from Purchase group by CampaignNo order by CampaignNo");
625		assertTrue(results.next());
626		assertEquals("Incorrect CampaignNo", 1, results.getInt(1));
627		assertEquals("Incorrect sum PurchaseCt", 4 + 1 + 11, results.getInt(2));
628		assertEquals("Incorrect avg PurchaseCt", Math.round((4 + 1 + 11) / 3.0 * 10), results.getInt(3));
629		assertTrue(results.next());
630		assertEquals("Incorrect CampaignNo", 21, results.getInt(1));
631		assertEquals("Incorrect sum PurchaseCt", 1 + 3, results.getInt(2));
632		assertEquals("Incorrect avg PurchaseCt", Math.round((1 + 3) / 2.0 * 10), results.getInt(3));
633		assertTrue(results.next());
634		assertEquals("Incorrect CampaignNo", 61, results.getInt(1));
635		assertEquals("Incorrect sum PurchaseCt", 4, results.getInt(2));
636		assertEquals("Incorrect avg PurchaseCt", 4 * 10, results.getInt(3));
637		assertFalse(results.next());
638
639		results.close();
640		stmt.close();
641		conn.close();
	671
	672	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
	673
	674	Statement stmt = conn.createStatement();
	675
	676	ResultSet results = stmt.executeQuery("select CampaignNo, sum(distinct PurchaseCt), round(avg(distinct PurchaseCt)*10) from Purchase group by CampaignNo order by CampaignNo"))
	677	{
	678	assertTrue(results.next());
	679	assertEquals("Incorrect CampaignNo", 1, results.getInt(1));
	680	assertEquals("Incorrect sum PurchaseCt", 4 + 1 + 11, results.getInt(2));
	681	assertEquals("Incorrect avg PurchaseCt", Math.round((4 + 1 + 11) / 3.0 * 10), results.getInt(3));
	682	assertTrue(results.next());
	683	assertEquals("Incorrect CampaignNo", 21, results.getInt(1));
	684	assertEquals("Incorrect sum PurchaseCt", 1 + 3, results.getInt(2));
	685	assertEquals("Incorrect avg PurchaseCt", Math.round((1 + 3) / 2.0 * 10), results.getInt(3));
	686	assertTrue(results.next());
	687	assertEquals("Incorrect CampaignNo", 61, results.getInt(1));
	688	assertEquals("Incorrect sum PurchaseCt", 4, results.getInt(2));
	689	assertEquals("Incorrect avg PurchaseCt", 4 * 10, results.getInt(3));
	690	assertFalse(results.next());
	691	}
642	692	}
643	693	}

+446

-446

src/test/java/org/relique/jdbc/csv/TestJoinedTables.java less more

66	66
67	67	// setting both transposedLines and skipTransposedFields informs the
68	68	// driver we are receiving a compacted join
69
70		// L,P,K,U,W, leaving D,T as regular fields, V as matrix of joined values
	69
	70	// L,P,K,U,W, leaving D,T as regular fields, V as matrix of joined values
71	71	props.put("transposedLines", "5");
72
	72
73	73	// the first column in the transposed table holds the (ignored) header.
74	74	props.put("transposedFieldsToSkip", "1");
75	75	// the driver must be told that there is no header.
76	76	props.put("suppressHeaders", "true");
77	77
78		ResultSet results = null;
79
80		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	78	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
81	79	+ filePath, props);
82		Statement stmt = conn.createStatement();
83
84		results = stmt.executeQuery("SELECT * FROM twojoinedtables01");
85		assertTrue("there should be results", results.next());
86		assertEquals("l1", results.getObject("L"));
87		assertEquals("p1", results.getObject("P"));
88		assertEquals("k1", results.getObject("K"));
89		assertEquals("u1", results.getObject("U"));
90		assertEquals("w1", results.getObject("W"));
91		assertEquals("d1", results.getObject("D"));
92		assertEquals("t1", results.getObject("T"));
93		assertEquals("v11", results.getObject("V"));
94
95		assertTrue("there should be results", results.next());
96		assertEquals("l2", results.getObject("L"));
97		assertEquals("p2", results.getObject("P"));
98		assertEquals("k2", results.getObject("K"));
99		assertEquals("u2", results.getObject("U"));
100		assertEquals("w2", results.getObject("W"));
101		assertEquals("d1", results.getObject("D"));
102		assertEquals("t1", results.getObject("T"));
103		assertEquals("v12", results.getObject("V"));
104
105		assertTrue(results.next());
106		assertEquals("l3", results.getObject("L"));
107		assertEquals("p3", results.getObject("P"));
108		assertEquals("k3", results.getObject("K"));
109		assertEquals("u3", results.getObject("U"));
110		assertEquals("w3", results.getObject("W"));
111		assertEquals("d1", results.getObject("D"));
112		assertEquals("t1", results.getObject("T"));
113		assertEquals("v13", results.getObject("V"));
114
115		assertTrue(results.next());
116		assertEquals("l1", results.getObject("L"));
117		assertEquals("p1", results.getObject("P"));
118		assertEquals("k1", results.getObject("K"));
119		assertEquals("u1", results.getObject("U"));
120		assertEquals("w1", results.getObject("W"));
121		assertEquals("d2", results.getObject("D"));
122		assertEquals("t2", results.getObject("T"));
123		assertEquals("v21", results.getObject("V"));
124
125		assertTrue(results.next());
126		assertEquals("l2", results.getObject("L"));
127		assertEquals("p2", results.getObject("P"));
128		assertEquals("k2", results.getObject("K"));
129		assertEquals("u2", results.getObject("U"));
130		assertEquals("w2", results.getObject("W"));
131		assertEquals("d2", results.getObject("D"));
132		assertEquals("t2", results.getObject("T"));
133		assertEquals("v22", results.getObject("V"));
134
135		assertTrue(results.next());
136		assertEquals("l3", results.getObject("L"));
137		assertEquals("p3", results.getObject("P"));
138		assertEquals("k3", results.getObject("K"));
139		assertEquals("u3", results.getObject("U"));
140		assertEquals("w3", results.getObject("W"));
141		assertEquals("d2", results.getObject("D"));
142		assertEquals("t2", results.getObject("T"));
143		assertEquals("v23", results.getObject("V"));
144
145		assertTrue(results.next());
146		assertEquals("l1", results.getObject("L"));
147		assertEquals("p1", results.getObject("P"));
148		assertEquals("k1", results.getObject("K"));
149		assertEquals("u1", results.getObject("U"));
150		assertEquals("w1", results.getObject("W"));
151		assertEquals("d3", results.getObject("D"));
152		assertEquals("t3", results.getObject("T"));
153		assertEquals("v31", results.getObject("V"));
154
155		assertTrue(results.next());
156		assertEquals("l2", results.getObject("L"));
157		assertEquals("p2", results.getObject("P"));
158		assertEquals("k2", results.getObject("K"));
159		assertEquals("u2", results.getObject("U"));
160		assertEquals("w2", results.getObject("W"));
161		assertEquals("d3", results.getObject("D"));
162		assertEquals("t3", results.getObject("T"));
163		assertEquals("v32", results.getObject("V"));
164
165		assertTrue(results.next());
166		assertEquals("l3", results.getObject("L"));
167		assertEquals("p3", results.getObject("P"));
168		assertEquals("k3", results.getObject("K"));
169		assertEquals("u3", results.getObject("U"));
170		assertEquals("w3", results.getObject("W"));
171		assertEquals("d3", results.getObject("D"));
172		assertEquals("t3", results.getObject("T"));
173		assertEquals("v33", results.getObject("V"));
174
175		assertTrue(results.next());
176		assertEquals("l1", results.getObject("L"));
177		assertEquals("p1", results.getObject("P"));
178		assertEquals("k1", results.getObject("K"));
179		assertEquals("u1", results.getObject("U"));
180		assertEquals("w1", results.getObject("W"));
181		assertEquals("d4", results.getObject("D"));
182		assertEquals("t4", results.getObject("T"));
183		assertEquals("v41", results.getObject("V"));
184
185		assertTrue(results.next());
186		assertEquals("l2", results.getObject("L"));
187		assertEquals("p2", results.getObject("P"));
188		assertEquals("k2", results.getObject("K"));
189		assertEquals("u2", results.getObject("U"));
190		assertEquals("w2", results.getObject("W"));
191		assertEquals("d4", results.getObject("D"));
192		assertEquals("t4", results.getObject("T"));
193		assertEquals("v42", results.getObject("V"));
194
195		assertTrue(results.next());
196		assertEquals("l3", results.getObject("L"));
197		assertEquals("p3", results.getObject("P"));
198		assertEquals("k3", results.getObject("K"));
199		assertEquals("u3", results.getObject("U"));
200		assertEquals("w3", results.getObject("W"));
201		assertEquals("d4", results.getObject("D"));
202		assertEquals("t4", results.getObject("T"));
203		assertEquals("v43", results.getObject("V"));
204
205		assertTrue(results.next());
206		assertEquals("l1", results.getObject("L"));
207		assertEquals("p1", results.getObject("P"));
208		assertEquals("k1", results.getObject("K"));
209		assertEquals("u1", results.getObject("U"));
210		assertEquals("w1", results.getObject("W"));
211		assertEquals("d5", results.getObject("D"));
212		assertEquals("t5", results.getObject("T"));
213		assertEquals("v51", results.getObject("V"));
214
215		assertTrue(results.next());
216		assertEquals("l2", results.getObject("L"));
217		assertEquals("p2", results.getObject("P"));
218		assertEquals("k2", results.getObject("K"));
219		assertEquals("u2", results.getObject("U"));
220		assertEquals("w2", results.getObject("W"));
221		assertEquals("d5", results.getObject("D"));
222		assertEquals("t5", results.getObject("T"));
223		assertEquals("v52", results.getObject("V"));
224
225		assertTrue(results.next());
226		assertEquals("l3", results.getObject("L"));
227		assertEquals("p3", results.getObject("P"));
228		assertEquals("k3", results.getObject("K"));
229		assertEquals("u3", results.getObject("U"));
230		assertEquals("w3", results.getObject("W"));
231		assertEquals("d5", results.getObject("D"));
232		assertEquals("t5", results.getObject("T"));
233		assertEquals("v53", results.getObject("V"));
234
235		assertFalse(results.next());
	80	Statement stmt = conn.createStatement();
	81
	82	ResultSet results = stmt.executeQuery("SELECT * FROM twojoinedtables01"))
	83	{
	84	assertTrue("there should be results", results.next());
	85	assertEquals("l1", results.getObject("L"));
	86	assertEquals("p1", results.getObject("P"));
	87	assertEquals("k1", results.getObject("K"));
	88	assertEquals("u1", results.getObject("U"));
	89	assertEquals("w1", results.getObject("W"));
	90	assertEquals("d1", results.getObject("D"));
	91	assertEquals("t1", results.getObject("T"));
	92	assertEquals("v11", results.getObject("V"));
	93
	94	assertTrue("there should be results", results.next());
	95	assertEquals("l2", results.getObject("L"));
	96	assertEquals("p2", results.getObject("P"));
	97	assertEquals("k2", results.getObject("K"));
	98	assertEquals("u2", results.getObject("U"));
	99	assertEquals("w2", results.getObject("W"));
	100	assertEquals("d1", results.getObject("D"));
	101	assertEquals("t1", results.getObject("T"));
	102	assertEquals("v12", results.getObject("V"));
	103
	104	assertTrue(results.next());
	105	assertEquals("l3", results.getObject("L"));
	106	assertEquals("p3", results.getObject("P"));
	107	assertEquals("k3", results.getObject("K"));
	108	assertEquals("u3", results.getObject("U"));
	109	assertEquals("w3", results.getObject("W"));
	110	assertEquals("d1", results.getObject("D"));
	111	assertEquals("t1", results.getObject("T"));
	112	assertEquals("v13", results.getObject("V"));
	113
	114	assertTrue(results.next());
	115	assertEquals("l1", results.getObject("L"));
	116	assertEquals("p1", results.getObject("P"));
	117	assertEquals("k1", results.getObject("K"));
	118	assertEquals("u1", results.getObject("U"));
	119	assertEquals("w1", results.getObject("W"));
	120	assertEquals("d2", results.getObject("D"));
	121	assertEquals("t2", results.getObject("T"));
	122	assertEquals("v21", results.getObject("V"));
	123
	124	assertTrue(results.next());
	125	assertEquals("l2", results.getObject("L"));
	126	assertEquals("p2", results.getObject("P"));
	127	assertEquals("k2", results.getObject("K"));
	128	assertEquals("u2", results.getObject("U"));
	129	assertEquals("w2", results.getObject("W"));
	130	assertEquals("d2", results.getObject("D"));
	131	assertEquals("t2", results.getObject("T"));
	132	assertEquals("v22", results.getObject("V"));
	133
	134	assertTrue(results.next());
	135	assertEquals("l3", results.getObject("L"));
	136	assertEquals("p3", results.getObject("P"));
	137	assertEquals("k3", results.getObject("K"));
	138	assertEquals("u3", results.getObject("U"));
	139	assertEquals("w3", results.getObject("W"));
	140	assertEquals("d2", results.getObject("D"));
	141	assertEquals("t2", results.getObject("T"));
	142	assertEquals("v23", results.getObject("V"));
	143
	144	assertTrue(results.next());
	145	assertEquals("l1", results.getObject("L"));
	146	assertEquals("p1", results.getObject("P"));
	147	assertEquals("k1", results.getObject("K"));
	148	assertEquals("u1", results.getObject("U"));
	149	assertEquals("w1", results.getObject("W"));
	150	assertEquals("d3", results.getObject("D"));
	151	assertEquals("t3", results.getObject("T"));
	152	assertEquals("v31", results.getObject("V"));
	153
	154	assertTrue(results.next());
	155	assertEquals("l2", results.getObject("L"));
	156	assertEquals("p2", results.getObject("P"));
	157	assertEquals("k2", results.getObject("K"));
	158	assertEquals("u2", results.getObject("U"));
	159	assertEquals("w2", results.getObject("W"));
	160	assertEquals("d3", results.getObject("D"));
	161	assertEquals("t3", results.getObject("T"));
	162	assertEquals("v32", results.getObject("V"));
	163
	164	assertTrue(results.next());
	165	assertEquals("l3", results.getObject("L"));
	166	assertEquals("p3", results.getObject("P"));
	167	assertEquals("k3", results.getObject("K"));
	168	assertEquals("u3", results.getObject("U"));
	169	assertEquals("w3", results.getObject("W"));
	170	assertEquals("d3", results.getObject("D"));
	171	assertEquals("t3", results.getObject("T"));
	172	assertEquals("v33", results.getObject("V"));
	173
	174	assertTrue(results.next());
	175	assertEquals("l1", results.getObject("L"));
	176	assertEquals("p1", results.getObject("P"));
	177	assertEquals("k1", results.getObject("K"));
	178	assertEquals("u1", results.getObject("U"));
	179	assertEquals("w1", results.getObject("W"));
	180	assertEquals("d4", results.getObject("D"));
	181	assertEquals("t4", results.getObject("T"));
	182	assertEquals("v41", results.getObject("V"));
	183
	184	assertTrue(results.next());
	185	assertEquals("l2", results.getObject("L"));
	186	assertEquals("p2", results.getObject("P"));
	187	assertEquals("k2", results.getObject("K"));
	188	assertEquals("u2", results.getObject("U"));
	189	assertEquals("w2", results.getObject("W"));
	190	assertEquals("d4", results.getObject("D"));
	191	assertEquals("t4", results.getObject("T"));
	192	assertEquals("v42", results.getObject("V"));
	193
	194	assertTrue(results.next());
	195	assertEquals("l3", results.getObject("L"));
	196	assertEquals("p3", results.getObject("P"));
	197	assertEquals("k3", results.getObject("K"));
	198	assertEquals("u3", results.getObject("U"));
	199	assertEquals("w3", results.getObject("W"));
	200	assertEquals("d4", results.getObject("D"));
	201	assertEquals("t4", results.getObject("T"));
	202	assertEquals("v43", results.getObject("V"));
	203
	204	assertTrue(results.next());
	205	assertEquals("l1", results.getObject("L"));
	206	assertEquals("p1", results.getObject("P"));
	207	assertEquals("k1", results.getObject("K"));
	208	assertEquals("u1", results.getObject("U"));
	209	assertEquals("w1", results.getObject("W"));
	210	assertEquals("d5", results.getObject("D"));
	211	assertEquals("t5", results.getObject("T"));
	212	assertEquals("v51", results.getObject("V"));
	213
	214	assertTrue(results.next());
	215	assertEquals("l2", results.getObject("L"));
	216	assertEquals("p2", results.getObject("P"));
	217	assertEquals("k2", results.getObject("K"));
	218	assertEquals("u2", results.getObject("U"));
	219	assertEquals("w2", results.getObject("W"));
	220	assertEquals("d5", results.getObject("D"));
	221	assertEquals("t5", results.getObject("T"));
	222	assertEquals("v52", results.getObject("V"));
	223
	224	assertTrue(results.next());
	225	assertEquals("l3", results.getObject("L"));
	226	assertEquals("p3", results.getObject("P"));
	227	assertEquals("k3", results.getObject("K"));
	228	assertEquals("u3", results.getObject("U"));
	229	assertEquals("w3", results.getObject("W"));
	230	assertEquals("d5", results.getObject("D"));
	231	assertEquals("t5", results.getObject("T"));
	232	assertEquals("v53", results.getObject("V"));
	233
	234	assertFalse(results.next());
	235	}
236	236	}
237	237
238	238	@Test

241	241	Properties props = new Properties();
242	242	props.put("fileExtension", ".txt");
243	243	props.put("headerline", "P,D,T,V");
244
	244
245	245	// setting both transposedLines and skipTransposedFields informs the
246	246	// driver we are receiving a compacted join
247
	247
248	248	// transposedLines <- 1; leaving D,T as regular fields, V as matrix of
249	249	// joined values
250	250	props.put("transposedLines", "1");
251
	251
252	252	// transposedFieldsToSkip <- 2; the file looks like a regular CSV (with
253	253	// variable header)
254	254	props.put("transposedFieldsToSkip", "2");
255	255	// the driver must be told that there is no header.
256	256	props.put("suppressHeaders", "true");
257	257
258		ResultSet results = null;
259
260		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	258	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
261	259	+ filePath, props);
262		Statement stmt = conn.createStatement();
263
264		results = stmt.executeQuery("SELECT * FROM twojoinedtables02");
265		assertTrue(results.next());
266		assertEquals("p1", results.getObject("P"));
267		assertEquals("d1", results.getObject("D"));
268		assertEquals("t1", results.getObject("T"));
269		assertEquals("v11", results.getObject("V"));
270
271		assertTrue(results.next());
272		assertEquals("p2", results.getObject("P"));
273		assertEquals("d1", results.getObject("D"));
274		assertEquals("t1", results.getObject("T"));
275		assertEquals("v12", results.getObject("V"));
276
277		assertTrue(results.next());
278		assertEquals("p3", results.getObject("P"));
279		assertEquals("d1", results.getObject("D"));
280		assertEquals("t1", results.getObject("T"));
281		assertEquals("v13", results.getObject("V"));
282
283		assertTrue(results.next());
284		assertEquals("p4", results.getObject("P"));
285		assertEquals("d1", results.getObject("D"));
286		assertEquals("t1", results.getObject("T"));
287		assertEquals("v14", results.getObject("V"));
288
289		assertTrue(results.next());
290		assertEquals("p5", results.getObject("P"));
291		assertEquals("d1", results.getObject("D"));
292		assertEquals("t1", results.getObject("T"));
293		assertEquals("v15", results.getObject("V"));
294
295		assertTrue(results.next());
296		assertEquals("p1", results.getObject("P"));
297		assertEquals("d2", results.getObject("D"));
298		assertEquals("t2", results.getObject("T"));
299		assertEquals("v21", results.getObject("V"));
300
301		assertTrue(results.next());
302		assertEquals("p2", results.getObject("P"));
303		assertEquals("d2", results.getObject("D"));
304		assertEquals("t2", results.getObject("T"));
305		assertEquals("v22", results.getObject("V"));
306
307		assertTrue(results.next());
308		assertEquals("p3", results.getObject("P"));
309		assertEquals("d2", results.getObject("D"));
310		assertEquals("t2", results.getObject("T"));
311		assertEquals("v23", results.getObject("V"));
312
313		assertTrue(results.next());
314		assertEquals("p4", results.getObject("P"));
315		assertEquals("d2", results.getObject("D"));
316		assertEquals("t2", results.getObject("T"));
317		assertEquals("v24", results.getObject("V"));
318
319		assertTrue(results.next());
320		assertEquals("p5", results.getObject("P"));
321		assertEquals("d2", results.getObject("D"));
322		assertEquals("t2", results.getObject("T"));
323		assertEquals("v25", results.getObject("V"));
324
325		assertTrue(results.next());
326		assertEquals("p1", results.getObject("P"));
327		assertEquals("d3", results.getObject("D"));
328		assertEquals("t3", results.getObject("T"));
329		assertEquals("v31", results.getObject("V"));
330
331		assertTrue(results.next());
332		assertEquals("p2", results.getObject("P"));
333		assertEquals("d3", results.getObject("D"));
334		assertEquals("t3", results.getObject("T"));
335		assertEquals("v32", results.getObject("V"));
336
337		assertTrue(results.next());
338		assertEquals("p3", results.getObject("P"));
339		assertEquals("d3", results.getObject("D"));
340		assertEquals("t3", results.getObject("T"));
341		assertEquals("v33", results.getObject("V"));
342
343		assertTrue(results.next());
344		assertEquals("p4", results.getObject("P"));
345		assertEquals("d3", results.getObject("D"));
346		assertEquals("t3", results.getObject("T"));
347		assertEquals("v34", results.getObject("V"));
348
349		assertTrue(results.next());
350		assertEquals("p5", results.getObject("P"));
351		assertEquals("d3", results.getObject("D"));
352		assertEquals("t3", results.getObject("T"));
353		assertEquals("v35", results.getObject("V"));
354
355		assertFalse(results.next());
	260	Statement stmt = conn.createStatement();
	261
	262	ResultSet results = stmt.executeQuery("SELECT * FROM twojoinedtables02"))
	263	{
	264	assertTrue(results.next());
	265	assertEquals("p1", results.getObject("P"));
	266	assertEquals("d1", results.getObject("D"));
	267	assertEquals("t1", results.getObject("T"));
	268	assertEquals("v11", results.getObject("V"));
	269
	270	assertTrue(results.next());
	271	assertEquals("p2", results.getObject("P"));
	272	assertEquals("d1", results.getObject("D"));
	273	assertEquals("t1", results.getObject("T"));
	274	assertEquals("v12", results.getObject("V"));
	275
	276	assertTrue(results.next());
	277	assertEquals("p3", results.getObject("P"));
	278	assertEquals("d1", results.getObject("D"));
	279	assertEquals("t1", results.getObject("T"));
	280	assertEquals("v13", results.getObject("V"));
	281
	282	assertTrue(results.next());
	283	assertEquals("p4", results.getObject("P"));
	284	assertEquals("d1", results.getObject("D"));
	285	assertEquals("t1", results.getObject("T"));
	286	assertEquals("v14", results.getObject("V"));
	287
	288	assertTrue(results.next());
	289	assertEquals("p5", results.getObject("P"));
	290	assertEquals("d1", results.getObject("D"));
	291	assertEquals("t1", results.getObject("T"));
	292	assertEquals("v15", results.getObject("V"));
	293
	294	assertTrue(results.next());
	295	assertEquals("p1", results.getObject("P"));
	296	assertEquals("d2", results.getObject("D"));
	297	assertEquals("t2", results.getObject("T"));
	298	assertEquals("v21", results.getObject("V"));
	299
	300	assertTrue(results.next());
	301	assertEquals("p2", results.getObject("P"));
	302	assertEquals("d2", results.getObject("D"));
	303	assertEquals("t2", results.getObject("T"));
	304	assertEquals("v22", results.getObject("V"));
	305
	306	assertTrue(results.next());
	307	assertEquals("p3", results.getObject("P"));
	308	assertEquals("d2", results.getObject("D"));
	309	assertEquals("t2", results.getObject("T"));
	310	assertEquals("v23", results.getObject("V"));
	311
	312	assertTrue(results.next());
	313	assertEquals("p4", results.getObject("P"));
	314	assertEquals("d2", results.getObject("D"));
	315	assertEquals("t2", results.getObject("T"));
	316	assertEquals("v24", results.getObject("V"));
	317
	318	assertTrue(results.next());
	319	assertEquals("p5", results.getObject("P"));
	320	assertEquals("d2", results.getObject("D"));
	321	assertEquals("t2", results.getObject("T"));
	322	assertEquals("v25", results.getObject("V"));
	323
	324	assertTrue(results.next());
	325	assertEquals("p1", results.getObject("P"));
	326	assertEquals("d3", results.getObject("D"));
	327	assertEquals("t3", results.getObject("T"));
	328	assertEquals("v31", results.getObject("V"));
	329
	330	assertTrue(results.next());
	331	assertEquals("p2", results.getObject("P"));
	332	assertEquals("d3", results.getObject("D"));
	333	assertEquals("t3", results.getObject("T"));
	334	assertEquals("v32", results.getObject("V"));
	335
	336	assertTrue(results.next());
	337	assertEquals("p3", results.getObject("P"));
	338	assertEquals("d3", results.getObject("D"));
	339	assertEquals("t3", results.getObject("T"));
	340	assertEquals("v33", results.getObject("V"));
	341
	342	assertTrue(results.next());
	343	assertEquals("p4", results.getObject("P"));
	344	assertEquals("d3", results.getObject("D"));
	345	assertEquals("t3", results.getObject("T"));
	346	assertEquals("v34", results.getObject("V"));
	347
	348	assertTrue(results.next());
	349	assertEquals("p5", results.getObject("P"));
	350	assertEquals("d3", results.getObject("D"));
	351	assertEquals("t3", results.getObject("T"));
	352	assertEquals("v35", results.getObject("V"));
	353
	354	assertFalse(results.next());
	355	}
356	356	}
357	357
358	358	@Test

361	361	Properties props = new Properties();
362	362	props.put("fileExtension", ".txt");
363	363	props.put("headerline", "P,J,D,T,V");
364
	364
365	365	// setting both transposedLines and skipTransposedFields informs the
366	366	// driver we are receiving a compacted join
367
	367
368	368	// transposedLines <- 1; leaving D,T as regular fields, V as matrix of
369	369	// joined values
370	370	props.put("transposedLines", "1");
371
	371
372	372	// transposedFieldsToSkip <- 2; the file looks like a regular CSV (with
373	373	// variable header)
374	374	props.put("transposedFieldsToSkip", "3");
375	375	// the driver must be told that there is no header.
376	376	props.put("suppressHeaders", "true");
377
	377
378	378	props.put("indexedFiles", "True");
379	379	props.put("fileTailPattern", "_(.*)");
380	380	props.put("fileTailParts", "junk");
381	381	props.put("fileTailPrepend", "true");
382	382
383		ResultSet results = null;
384
385		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	383	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
386	384	+ filePath, props);
387		Statement stmt = conn.createStatement();
388
389		results = stmt.executeQuery("SELECT * FROM twojoinedtablesindex");
390		assertTrue(results.next());
391		assertEquals("p1", results.getObject("P"));
392		assertEquals("1", results.getObject("J"));
393		assertEquals("d1", results.getObject("D"));
394		assertEquals("t1", results.getObject("T"));
395		assertEquals("v11", results.getObject("V"));
396
397		assertTrue(results.next());
398		assertEquals("p2", results.getObject("P"));
399		assertEquals("1", results.getObject("J"));
400		assertEquals("d1", results.getObject("D"));
401		assertEquals("t1", results.getObject("T"));
402		assertEquals("v12", results.getObject("V"));
403
404		assertTrue(results.next());
405		assertEquals("p3", results.getObject("P"));
406		assertEquals("1", results.getObject("J"));
407		assertEquals("d1", results.getObject("D"));
408		assertEquals("t1", results.getObject("T"));
409		assertEquals("v13", results.getObject("V"));
410
411		assertTrue(results.next());
412		assertEquals("1", results.getObject("J"));
413		assertEquals("p1", results.getObject("P"));
414		assertEquals("d2", results.getObject("D"));
415		assertEquals("t2", results.getObject("T"));
416		assertEquals("v21", results.getObject("V"));
417
418		assertTrue(results.next());
419		assertEquals("1", results.getObject("J"));
420		assertEquals("p2", results.getObject("P"));
421		assertEquals("d2", results.getObject("D"));
422		assertEquals("t2", results.getObject("T"));
423		assertEquals("v22", results.getObject("V"));
424
425		assertTrue(results.next());
426		assertEquals("1", results.getObject("J"));
427		assertEquals("p3", results.getObject("P"));
428		assertEquals("d2", results.getObject("D"));
429		assertEquals("t2", results.getObject("T"));
430		assertEquals("v23", results.getObject("V"));
431
432		assertTrue(results.next());
433		assertEquals("p1", results.getObject("P"));
434		assertEquals("1", results.getObject("J"));
435		assertEquals("d3", results.getObject("D"));
436		assertEquals("t3", results.getObject("T"));
437		assertEquals("v31", results.getObject("V"));
438
439		assertTrue(results.next());
440		assertEquals("p2", results.getObject("P"));
441		assertEquals("1", results.getObject("J"));
442		assertEquals("d3", results.getObject("D"));
443		assertEquals("t3", results.getObject("T"));
444		assertEquals("v32", results.getObject("V"));
445
446		assertTrue(results.next());
447		assertEquals("p3", results.getObject("P"));
448		assertEquals("1", results.getObject("J"));
449		assertEquals("d3", results.getObject("D"));
450		assertEquals("t3", results.getObject("T"));
451		assertEquals("v33", results.getObject("V"));
452
453		assertTrue(results.next());
454		assertEquals("p1", results.getObject("P"));
455		assertEquals("2", results.getObject("J"));
456		assertEquals("d7", results.getObject("D"));
457		assertEquals("t7", results.getObject("T"));
458		assertEquals("v71", results.getObject("V"));
459
460		assertTrue(results.next());
461		assertEquals("p2", results.getObject("P"));
462		assertEquals("2", results.getObject("J"));
463		assertEquals("d7", results.getObject("D"));
464		assertEquals("t7", results.getObject("T"));
465		assertEquals("v72", results.getObject("V"));
466
467		assertTrue(results.next());
468		assertEquals("p3", results.getObject("P"));
469		assertEquals("2", results.getObject("J"));
470		assertEquals("d7", results.getObject("D"));
471		assertEquals("t7", results.getObject("T"));
472		assertEquals("v73", results.getObject("V"));
473
474		assertTrue(results.next());
475		assertEquals("p1", results.getObject("P"));
476		assertEquals("2", results.getObject("J"));
477		assertEquals("d8", results.getObject("D"));
478		assertEquals("t8", results.getObject("T"));
479		assertEquals("v81", results.getObject("V"));
480
481		assertTrue(results.next());
482		assertEquals("2", results.getObject("J"));
483		assertEquals("p2", results.getObject("P"));
484		assertEquals("d8", results.getObject("D"));
485		assertEquals("t8", results.getObject("T"));
486		assertEquals("v82", results.getObject("V"));
487
488		assertTrue(results.next());
489		assertEquals("2", results.getObject("J"));
490		assertEquals("p3", results.getObject("P"));
491		assertEquals("d8", results.getObject("D"));
492		assertEquals("t8", results.getObject("T"));
493		assertEquals("v83", results.getObject("V"));
494
495		assertTrue(results.next());
496		assertEquals("p1", results.getObject("P"));
497		assertEquals("2", results.getObject("J"));
498		assertEquals("d9", results.getObject("D"));
499		assertEquals("t9", results.getObject("T"));
500		assertEquals("v91", results.getObject("V"));
501
502		assertTrue(results.next());
503		assertEquals("p2", results.getObject("P"));
504		assertEquals("2", results.getObject("J"));
505		assertEquals("d9", results.getObject("D"));
506		assertEquals("t9", results.getObject("T"));
507		assertEquals("v92", results.getObject("V"));
508
509		assertTrue(results.next());
510		assertEquals("p3", results.getObject("P"));
511		assertEquals("2", results.getObject("J"));
512		assertEquals("d9", results.getObject("D"));
513		assertEquals("t9", results.getObject("T"));
514		assertEquals("v93", results.getObject("V"));
515
516		// assertFalse(results.next()); don't test this: I've added a third file for an other test.
	385	Statement stmt = conn.createStatement();
	386
	387	ResultSet results = stmt.executeQuery("SELECT * FROM twojoinedtablesindex"))
	388	{
	389	assertTrue(results.next());
	390	assertEquals("p1", results.getObject("P"));
	391	assertEquals("1", results.getObject("J"));
	392	assertEquals("d1", results.getObject("D"));
	393	assertEquals("t1", results.getObject("T"));
	394	assertEquals("v11", results.getObject("V"));
	395
	396	assertTrue(results.next());
	397	assertEquals("p2", results.getObject("P"));
	398	assertEquals("1", results.getObject("J"));
	399	assertEquals("d1", results.getObject("D"));
	400	assertEquals("t1", results.getObject("T"));
	401	assertEquals("v12", results.getObject("V"));
	402
	403	assertTrue(results.next());
	404	assertEquals("p3", results.getObject("P"));
	405	assertEquals("1", results.getObject("J"));
	406	assertEquals("d1", results.getObject("D"));
	407	assertEquals("t1", results.getObject("T"));
	408	assertEquals("v13", results.getObject("V"));
	409
	410	assertTrue(results.next());
	411	assertEquals("1", results.getObject("J"));
	412	assertEquals("p1", results.getObject("P"));
	413	assertEquals("d2", results.getObject("D"));
	414	assertEquals("t2", results.getObject("T"));
	415	assertEquals("v21", results.getObject("V"));
	416
	417	assertTrue(results.next());
	418	assertEquals("1", results.getObject("J"));
	419	assertEquals("p2", results.getObject("P"));
	420	assertEquals("d2", results.getObject("D"));
	421	assertEquals("t2", results.getObject("T"));
	422	assertEquals("v22", results.getObject("V"));
	423
	424	assertTrue(results.next());
	425	assertEquals("1", results.getObject("J"));
	426	assertEquals("p3", results.getObject("P"));
	427	assertEquals("d2", results.getObject("D"));
	428	assertEquals("t2", results.getObject("T"));
	429	assertEquals("v23", results.getObject("V"));
	430
	431	assertTrue(results.next());
	432	assertEquals("p1", results.getObject("P"));
	433	assertEquals("1", results.getObject("J"));
	434	assertEquals("d3", results.getObject("D"));
	435	assertEquals("t3", results.getObject("T"));
	436	assertEquals("v31", results.getObject("V"));
	437
	438	assertTrue(results.next());
	439	assertEquals("p2", results.getObject("P"));
	440	assertEquals("1", results.getObject("J"));
	441	assertEquals("d3", results.getObject("D"));
	442	assertEquals("t3", results.getObject("T"));
	443	assertEquals("v32", results.getObject("V"));
	444
	445	assertTrue(results.next());
	446	assertEquals("p3", results.getObject("P"));
	447	assertEquals("1", results.getObject("J"));
	448	assertEquals("d3", results.getObject("D"));
	449	assertEquals("t3", results.getObject("T"));
	450	assertEquals("v33", results.getObject("V"));
	451
	452	assertTrue(results.next());
	453	assertEquals("p1", results.getObject("P"));
	454	assertEquals("2", results.getObject("J"));
	455	assertEquals("d7", results.getObject("D"));
	456	assertEquals("t7", results.getObject("T"));
	457	assertEquals("v71", results.getObject("V"));
	458
	459	assertTrue(results.next());
	460	assertEquals("p2", results.getObject("P"));
	461	assertEquals("2", results.getObject("J"));
	462	assertEquals("d7", results.getObject("D"));
	463	assertEquals("t7", results.getObject("T"));
	464	assertEquals("v72", results.getObject("V"));
	465
	466	assertTrue(results.next());
	467	assertEquals("p3", results.getObject("P"));
	468	assertEquals("2", results.getObject("J"));
	469	assertEquals("d7", results.getObject("D"));
	470	assertEquals("t7", results.getObject("T"));
	471	assertEquals("v73", results.getObject("V"));
	472
	473	assertTrue(results.next());
	474	assertEquals("p1", results.getObject("P"));
	475	assertEquals("2", results.getObject("J"));
	476	assertEquals("d8", results.getObject("D"));
	477	assertEquals("t8", results.getObject("T"));
	478	assertEquals("v81", results.getObject("V"));
	479
	480	assertTrue(results.next());
	481	assertEquals("2", results.getObject("J"));
	482	assertEquals("p2", results.getObject("P"));
	483	assertEquals("d8", results.getObject("D"));
	484	assertEquals("t8", results.getObject("T"));
	485	assertEquals("v82", results.getObject("V"));
	486
	487	assertTrue(results.next());
	488	assertEquals("2", results.getObject("J"));
	489	assertEquals("p3", results.getObject("P"));
	490	assertEquals("d8", results.getObject("D"));
	491	assertEquals("t8", results.getObject("T"));
	492	assertEquals("v83", results.getObject("V"));
	493
	494	assertTrue(results.next());
	495	assertEquals("p1", results.getObject("P"));
	496	assertEquals("2", results.getObject("J"));
	497	assertEquals("d9", results.getObject("D"));
	498	assertEquals("t9", results.getObject("T"));
	499	assertEquals("v91", results.getObject("V"));
	500
	501	assertTrue(results.next());
	502	assertEquals("p2", results.getObject("P"));
	503	assertEquals("2", results.getObject("J"));
	504	assertEquals("d9", results.getObject("D"));
	505	assertEquals("t9", results.getObject("T"));
	506	assertEquals("v92", results.getObject("V"));
	507
	508	assertTrue(results.next());
	509	assertEquals("p3", results.getObject("P"));
	510	assertEquals("2", results.getObject("J"));
	511	assertEquals("d9", results.getObject("D"));
	512	assertEquals("t9", results.getObject("T"));
	513	assertEquals("v93", results.getObject("V"));
	514
	515	// assertFalse(results.next()); don't test this: I've added a third file for an other test.
	516	}
517	517	}
518	518
519	519	@Test

523	523	Properties props = new Properties();
524	524	props.put("fileExtension", ".txt");
525	525	props.put("headerline", "P,J,D,T,V");
526
	526
527	527	// setting both transposedLines and skipTransposedFields informs the
528	528	// driver we are receiving a compacted join
529
	529
530	530	// transposedLines <- 1; leaving D,T as regular fields, V as matrix of
531	531	// joined values
532	532	props.put("transposedLines", "1");
533
	533
534	534	// transposedFieldsToSkip <- 2; the file looks like a regular CSV (with
535	535	// variable header)
536	536	props.put("transposedFieldsToSkip", "3");
537	537	// the driver must be told that there is no header.
538	538	props.put("suppressHeaders", "true");
539
	539
540	540	props.put("indexedFiles", "True");
541	541	props.put("fileTailPattern", "_(.*)");
542	542	props.put("fileTailParts", "junk");
543	543	props.put("fileTailPrepend", "true");
544	544
545		ResultSet results = null;
546
547		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	545	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
548	546	+ filePath, props);
549		Statement stmt = conn.createStatement();
550
551		results = stmt.executeQuery("SELECT * FROM twojoinedtablesindex");
552		assertTrue(results.next());
553		assertTrue(results.next());
554		assertTrue(results.next());
555		assertTrue(results.next());
556		assertTrue(results.next());
557		assertTrue(results.next());
558		assertTrue(results.next());
559		assertTrue(results.next());
560		assertTrue(results.next());
561		assertTrue(results.next());
562		assertTrue(results.next());
563		assertTrue(results.next());
564		assertTrue(results.next());
565		assertTrue(results.next());
566		assertTrue(results.next());
567		assertTrue(results.next());
568		assertTrue(results.next());
569		assertTrue(results.next());
570
571		assertTrue(results.next());
572		assertEquals("p1", results.getObject("P"));
573		assertEquals("3", results.getObject("J"));
574		assertEquals("d1", results.getObject("D"));
575		assertEquals("t1", results.getObject("T"));
576		assertEquals("v11", results.getObject("V"));
577
578		assertTrue(results.next());
579		assertEquals("p2", results.getObject("P"));
580		assertEquals("3", results.getObject("J"));
581		assertEquals("d1", results.getObject("D"));
582		assertEquals("t1", results.getObject("T"));
583		assertEquals("v12", results.getObject("V"));
584
585		assertTrue(results.next()); // TODO: here it crashes
586		assertEquals("p1", results.getObject("P"));
587		assertEquals("3", results.getObject("J"));
588		assertEquals("d9", results.getObject("D"));
589		assertEquals("t9", results.getObject("T"));
590		assertEquals("v93", results.getObject("V"));
	547	Statement stmt = conn.createStatement();
	548
	549	ResultSet results = stmt.executeQuery("SELECT * FROM twojoinedtablesindex"))
	550	{
	551	assertTrue(results.next());
	552	assertTrue(results.next());
	553	assertTrue(results.next());
	554	assertTrue(results.next());
	555	assertTrue(results.next());
	556	assertTrue(results.next());
	557	assertTrue(results.next());
	558	assertTrue(results.next());
	559	assertTrue(results.next());
	560	assertTrue(results.next());
	561	assertTrue(results.next());
	562	assertTrue(results.next());
	563	assertTrue(results.next());
	564	assertTrue(results.next());
	565	assertTrue(results.next());
	566	assertTrue(results.next());
	567	assertTrue(results.next());
	568	assertTrue(results.next());
	569
	570	assertTrue(results.next());
	571	assertEquals("p1", results.getObject("P"));
	572	assertEquals("3", results.getObject("J"));
	573	assertEquals("d1", results.getObject("D"));
	574	assertEquals("t1", results.getObject("T"));
	575	assertEquals("v11", results.getObject("V"));
	576
	577	assertTrue(results.next());
	578	assertEquals("p2", results.getObject("P"));
	579	assertEquals("3", results.getObject("J"));
	580	assertEquals("d1", results.getObject("D"));
	581	assertEquals("t1", results.getObject("T"));
	582	assertEquals("v12", results.getObject("V"));
	583
	584	assertTrue(results.next()); // TODO: here it crashes
	585	assertEquals("p1", results.getObject("P"));
	586	assertEquals("3", results.getObject("J"));
	587	assertEquals("d9", results.getObject("D"));
	588	assertEquals("t9", results.getObject("T"));
	589	assertEquals("v93", results.getObject("V"));
	590	}
591	591	}
592	592	}

+140

-114

src/test/java/org/relique/jdbc/csv/TestLimitOffset.java less more

70	70	{
71	71	Properties props = new Properties();
72	72	props.put("columnTypes", "Integer,String,String,Date,Time");
73		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
74
75		Statement stmt = conn.createStatement();
76
77		ResultSet results = stmt
78		.executeQuery("select id from sample5 limit 4");
79		assertTrue(results.next());
80		assertEquals("The ID is wrong", 41, results.getInt("ID"));
81		assertTrue(results.next());
82		assertEquals("The ID is wrong", 1, results.getInt("ID"));
83		assertTrue(results.next());
84		assertEquals("The ID is wrong", 2, results.getInt("ID"));
85		assertTrue(results.next());
86		assertEquals("The ID is wrong", 3, results.getInt("ID"));
87		assertFalse(results.next());
	73
	74	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
	75
	76	Statement stmt = conn.createStatement();
	77
	78	ResultSet results = stmt
	79	.executeQuery("select id from sample5 limit 4"))
	80	{
	81	assertTrue(results.next());
	82	assertEquals("The ID is wrong", 41, results.getInt("ID"));
	83	assertTrue(results.next());
	84	assertEquals("The ID is wrong", 1, results.getInt("ID"));
	85	assertTrue(results.next());
	86	assertEquals("The ID is wrong", 2, results.getInt("ID"));
	87	assertTrue(results.next());
	88	assertEquals("The ID is wrong", 3, results.getInt("ID"));
	89	assertFalse(results.next());
	90	}
88	91	}
89	92
90	93	@Test

92	95	{
93	96	Properties props = new Properties();
94	97	props.put("columnTypes", "Integer,String,String,Date,Time");
95		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
96
97		Statement stmt = conn.createStatement();
98
99		ResultSet results = stmt
100		.executeQuery("select id from sample4 limit 999");
101		assertTrue(results.next());
102		assertEquals("The ID is wrong", 1, results.getInt("ID"));
103		assertTrue(results.next());
104		assertEquals("The ID is wrong", 2, results.getInt("ID"));
105		assertTrue(results.next());
106		assertEquals("The ID is wrong", 3, results.getInt("ID"));
107		assertTrue(results.next());
108		assertEquals("The ID is wrong", 4, results.getInt("ID"));
109		assertFalse(results.next());
	98
	99	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
	100
	101	Statement stmt = conn.createStatement();
	102
	103	ResultSet results = stmt
	104	.executeQuery("select id from sample4 limit 999"))
	105	{
	106	assertTrue(results.next());
	107	assertEquals("The ID is wrong", 1, results.getInt("ID"));
	108	assertTrue(results.next());
	109	assertEquals("The ID is wrong", 2, results.getInt("ID"));
	110	assertTrue(results.next());
	111	assertEquals("The ID is wrong", 3, results.getInt("ID"));
	112	assertTrue(results.next());
	113	assertEquals("The ID is wrong", 4, results.getInt("ID"));
	114	assertFalse(results.next());
	115	}
110	116	}
111	117
112	118	@Test

114	120	{
115	121	Properties props = new Properties();
116	122	props.put("columnTypes", "Integer,String,String,Date,Time");
117		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
118
119		Statement stmt = conn.createStatement();
120
121		ResultSet results = stmt
122		.executeQuery("select id from sample5 where id > 6 limit 3");
123		assertTrue(results.next());
124		assertEquals("The ID is wrong", 41, results.getInt("ID"));
125		assertTrue(results.next());
126		assertEquals("The ID is wrong", 7, results.getInt("ID"));
127		assertTrue(results.next());
128		assertEquals("The ID is wrong", 8, results.getInt("ID"));
129		assertFalse(results.next());
	123
	124	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
	125
	126	Statement stmt = conn.createStatement();
	127
	128	ResultSet results = stmt
	129	.executeQuery("select id from sample5 where id > 6 limit 3"))
	130	{
	131	assertTrue(results.next());
	132	assertEquals("The ID is wrong", 41, results.getInt("ID"));
	133	assertTrue(results.next());
	134	assertEquals("The ID is wrong", 7, results.getInt("ID"));
	135	assertTrue(results.next());
	136	assertEquals("The ID is wrong", 8, results.getInt("ID"));
	137	assertFalse(results.next());
	138	}
130	139	}
131	140
132	141	@Test

134	143	{
135	144	Properties props = new Properties();
136	145	props.put("columnTypes", "Integer,String,String,Date,Time");
137		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
138
139		Statement stmt = conn.createStatement();
140
141		ResultSet results = stmt
142		.executeQuery("select id, name from sample5 order by id desc limit 2");
143		assertTrue(results.next());
144		assertEquals("The ID is wrong", 41, results.getInt("ID"));
145		assertTrue(results.next());
146		assertEquals("The ID is wrong", 9, results.getInt("ID"));
147		assertFalse(results.next());
	146
	147	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
	148
	149	Statement stmt = conn.createStatement();
	150
	151	ResultSet results = stmt
	152	.executeQuery("select id, name from sample5 order by id desc limit 2"))
	153	{
	154	assertTrue(results.next());
	155	assertEquals("The ID is wrong", 41, results.getInt("ID"));
	156	assertTrue(results.next());
	157	assertEquals("The ID is wrong", 9, results.getInt("ID"));
	158	assertFalse(results.next());
	159	}
148	160	}
149	161
150	162	@Test

152	164	{
153	165	Properties props = new Properties();
154	166	props.put("columnTypes", "Integer,String,String,Date,Time");
155		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
156
157		Statement stmt = conn.createStatement();
158
159		ResultSet results = stmt
160		.executeQuery("select id from sample5 limit 9 offset 8");
161		assertTrue(results.next());
162		assertEquals("The ID is wrong", 8, results.getInt("ID"));
163		assertTrue(results.next());
164		assertEquals("The ID is wrong", 9, results.getInt("ID"));
165		assertFalse(results.next());
	167
	168	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
	169
	170	Statement stmt = conn.createStatement();
	171
	172	ResultSet results = stmt
	173	.executeQuery("select id from sample5 limit 9 offset 8"))
	174	{
	175	assertTrue(results.next());
	176	assertEquals("The ID is wrong", 8, results.getInt("ID"));
	177	assertTrue(results.next());
	178	assertEquals("The ID is wrong", 9, results.getInt("ID"));
	179	assertFalse(results.next());
	180	}
166	181	}
167	182
168	183	@Test

170	185	{
171	186	Properties props = new Properties();
172	187	props.put("columnTypes", "Integer,String,String,Date,Time");
173		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
174
175		Statement stmt = conn.createStatement();
176
177		ResultSet results = stmt
178		.executeQuery("select id from sample5 limit 99 offset 99");
179		assertFalse(results.next());
	188
	189	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
	190
	191	Statement stmt = conn.createStatement();
	192
	193	ResultSet results = stmt
	194	.executeQuery("select id from sample5 limit 99 offset 99"))
	195	{
	196	assertFalse(results.next());
	197	}
180	198	}
181	199
182	200	@Test

184	202	{
185	203	Properties props = new Properties();
186	204	props.put("columnTypes", "Integer,String,String,Date,Time");
187		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
188
189		Statement stmt = conn.createStatement();
190
191		ResultSet results = stmt
192		.executeQuery("select id from sample5 where id > 2 limit 3 offset 4");
193		assertTrue(results.next());
194		assertEquals("The ID is wrong", 6, results.getInt("ID"));
195		assertTrue(results.next());
196		assertEquals("The ID is wrong", 7, results.getInt("ID"));
197		assertTrue(results.next());
198		assertEquals("The ID is wrong", 8, results.getInt("ID"));
199		assertFalse(results.next());
	205
	206	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
	207
	208	Statement stmt = conn.createStatement();
	209
	210	ResultSet results = stmt
	211	.executeQuery("select id from sample5 where id > 2 limit 3 offset 4"))
	212	{
	213	assertTrue(results.next());
	214	assertEquals("The ID is wrong", 6, results.getInt("ID"));
	215	assertTrue(results.next());
	216	assertEquals("The ID is wrong", 7, results.getInt("ID"));
	217	assertTrue(results.next());
	218	assertEquals("The ID is wrong", 8, results.getInt("ID"));
	219	assertFalse(results.next());
	220	}
200	221	}
201	222
202	223	@Test

204	225	{
205	226	Properties props = new Properties();
206	227	props.put("columnTypes", "Integer,String,String,Date,Time");
207		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
208
209		Statement stmt = conn.createStatement();
210
211		ResultSet results = stmt
212		.executeQuery("select * from sample5 order by id limit 99 offset 5");
213		assertTrue(results.next());
214		assertEquals("The ID is wrong", 6, results.getInt("ID"));
215		assertTrue(results.next());
216		assertEquals("The ID is wrong", 7, results.getInt("ID"));
217		assertTrue(results.next());
218		assertEquals("The ID is wrong", 8, results.getInt("ID"));
219		assertTrue(results.next());
220		assertEquals("The ID is wrong", 9, results.getInt("ID"));
221		assertTrue(results.next());
222		assertEquals("The ID is wrong", 41, results.getInt("ID"));
223		assertFalse(results.next());
	228
	229	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
	230
	231	Statement stmt = conn.createStatement();
	232
	233	ResultSet results = stmt
	234	.executeQuery("select * from sample5 order by id limit 99 offset 5"))
	235	{
	236	assertTrue(results.next());
	237	assertEquals("The ID is wrong", 6, results.getInt("ID"));
	238	assertTrue(results.next());
	239	assertEquals("The ID is wrong", 7, results.getInt("ID"));
	240	assertTrue(results.next());
	241	assertEquals("The ID is wrong", 8, results.getInt("ID"));
	242	assertTrue(results.next());
	243	assertEquals("The ID is wrong", 9, results.getInt("ID"));
	244	assertTrue(results.next());
	245	assertEquals("The ID is wrong", 41, results.getInt("ID"));
	246	assertFalse(results.next());
	247	}
224	248	}
225	249
226	250	@Test

228	252	{
229	253	Properties props = new Properties();
230	254	props.put("columnTypes", "Integer,String,String,Date,Time");
231		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
232
233		Statement stmt = conn.createStatement();
234
235		try
236		{
237		stmt.executeQuery("select * from sample5 limit 5 offset -1");
238		fail("Should raise a java.sqlSQLException");
239		}
240		catch (SQLException e)
241		{
242		assertTrue(e.toString().startsWith("java.sql.SQLException: " + CsvResources.getString("syntaxError")));
	255
	256	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
	257
	258	Statement stmt = conn.createStatement())
	259	{
	260	try
	261	{
	262	stmt.executeQuery("select * from sample5 limit 5 offset -1");
	263	fail("Should raise a java.sqlSQLException");
	264	}
	265	catch (SQLException e)
	266	{
	267	assertTrue(e.toString().startsWith("java.sql.SQLException: " + CsvResources.getString("syntaxError")));
	268	}
243	269	}
244	270	}
245	271	}

+271

-246

src/test/java/org/relique/jdbc/csv/TestOrderBy.java less more

61	61	{
62	62	fail("Driver is not in the CLASSPATH -> " + e);
63	63	}
64		toUTC = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
65		toUTC.setTimeZone(TimeZone.getTimeZone("UTC"));
	64	toUTC = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
	65	toUTC.setTimeZone(TimeZone.getTimeZone("UTC"));
66	66	}
67	67
68	68	@Test

75	75	props.put("commentChar", "#");
76	76	props.put("columnTypes", "Integer,String");
77	77	props.put("charset", "UTF-8");
78		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
79
80		Statement stmt = conn.createStatement();
81
82		ResultSet results = stmt
83		.executeQuery("SELECT * FROM banks ORDER BY BANK_NAME");
84		assertTrue(results.next());
85		assertEquals("The BLZ is wrong", 10010424, results.getInt("BLZ"));
86		assertEquals("The BLZ_NAME is wrong", "Aareal Bank (Berlin)", results.getString("BANK_NAME"));
87		assertTrue(results.next());
88		assertEquals("The BLZ is wrong", 10020200, results.getInt("BLZ"));
89		assertEquals("The BLZ_NAME is wrong", "BHF-BANK (Berlin)", results.getString("BANK_NAME"));
90		assertTrue(results.next());
91		assertEquals("The BLZ is wrong", 10020500, results.getInt("BLZ"));
92		assertEquals("The BLZ_NAME is wrong", "Bank f\u00FCr Sozialwirtschaft (Berlin)", results.getString("BANK_NAME"));
93		assertTrue(results.next());
94		assertEquals("The BLZ is wrong", 10020000, results.getInt("BLZ"));
95		assertEquals("The BLZ_NAME is wrong", "Berliner Bank -alt- (Berlin)", results.getString("BANK_NAME"));
96		assertTrue(results.next());
97		assertEquals("The BLZ is wrong", 10000000, results.getInt("BLZ"));
98		assertEquals("The BLZ_NAME is wrong", "Bundesbank (Berlin)", results.getString("BANK_NAME"));
99		assertTrue(results.next());
100		assertEquals("The BLZ is wrong", 10020400, results.getInt("BLZ"));
101		assertEquals("The BLZ_NAME is wrong", "Citadele Bank Zndl Deutschland (M\u00FCnchen)", results.getString("BANK_NAME"));
102		assertTrue(results.next());
103		assertEquals("The BLZ is wrong", 10019610, results.getInt("BLZ"));
104		assertEquals("The BLZ_NAME is wrong", "Dexia Kommunalbank Deutschland (Berlin)", results.getString("BANK_NAME"));
105		assertTrue(results.next());
106		assertEquals("The BLZ is wrong", 10010010, results.getInt("BLZ"));
107		assertEquals("The BLZ_NAME is wrong", "Postbank (Berlin)", results.getString("BANK_NAME"));
108		assertTrue(results.next());
109		assertEquals("The BLZ is wrong", 10010111, results.getInt("BLZ"));
110		assertEquals("The BLZ_NAME is wrong", "SEB (Berlin)", results.getString("BANK_NAME"));
111		assertTrue(results.next());
112		assertEquals("The BLZ is wrong", 10010222, results.getInt("BLZ"));
113		assertEquals("The BLZ_NAME is wrong", "The Royal Bank of Scotland, Niederlassung Deutschland (Berlin)", results.getString("BANK_NAME"));
114		assertFalse(results.next());
	78
	79	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
	80
	81	Statement stmt = conn.createStatement();
	82
	83	ResultSet results = stmt
	84	.executeQuery("SELECT * FROM banks ORDER BY BANK_NAME"))
	85	{
	86	assertTrue(results.next());
	87	assertEquals("The BLZ is wrong", 10010424, results.getInt("BLZ"));
	88	assertEquals("The BLZ_NAME is wrong", "Aareal Bank (Berlin)", results.getString("BANK_NAME"));
	89	assertTrue(results.next());
	90	assertEquals("The BLZ is wrong", 10020200, results.getInt("BLZ"));
	91	assertEquals("The BLZ_NAME is wrong", "BHF-BANK (Berlin)", results.getString("BANK_NAME"));
	92	assertTrue(results.next());
	93	assertEquals("The BLZ is wrong", 10020500, results.getInt("BLZ"));
	94	assertEquals("The BLZ_NAME is wrong", "Bank f\u00FCr Sozialwirtschaft (Berlin)", results.getString("BANK_NAME"));
	95	assertTrue(results.next());
	96	assertEquals("The BLZ is wrong", 10020000, results.getInt("BLZ"));
	97	assertEquals("The BLZ_NAME is wrong", "Berliner Bank -alt- (Berlin)", results.getString("BANK_NAME"));
	98	assertTrue(results.next());
	99	assertEquals("The BLZ is wrong", 10000000, results.getInt("BLZ"));
	100	assertEquals("The BLZ_NAME is wrong", "Bundesbank (Berlin)", results.getString("BANK_NAME"));
	101	assertTrue(results.next());
	102	assertEquals("The BLZ is wrong", 10020400, results.getInt("BLZ"));
	103	assertEquals("The BLZ_NAME is wrong", "Citadele Bank Zndl Deutschland (M\u00FCnchen)", results.getString("BANK_NAME"));
	104	assertTrue(results.next());
	105	assertEquals("The BLZ is wrong", 10019610, results.getInt("BLZ"));
	106	assertEquals("The BLZ_NAME is wrong", "Dexia Kommunalbank Deutschland (Berlin)", results.getString("BANK_NAME"));
	107	assertTrue(results.next());
	108	assertEquals("The BLZ is wrong", 10010010, results.getInt("BLZ"));
	109	assertEquals("The BLZ_NAME is wrong", "Postbank (Berlin)", results.getString("BANK_NAME"));
	110	assertTrue(results.next());
	111	assertEquals("The BLZ is wrong", 10010111, results.getInt("BLZ"));
	112	assertEquals("The BLZ_NAME is wrong", "SEB (Berlin)", results.getString("BANK_NAME"));
	113	assertTrue(results.next());
	114	assertEquals("The BLZ is wrong", 10010222, results.getInt("BLZ"));
	115	assertEquals("The BLZ_NAME is wrong", "The Royal Bank of Scotland, Niederlassung Deutschland (Berlin)", results.getString("BANK_NAME"));
	116	assertFalse(results.next());
	117	}
115	118	}
116	119
117	120	@Test

119	122	{
120	123	Properties props = new Properties();
121	124	props.put("columnTypes", "Int,String,String,Timestamp");
122		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
123
124		Statement stmt = conn.createStatement();
125
126		ResultSet results = stmt
127		.executeQuery("SELECT * FROM sample5 ORDER BY 1");
128		assertTrue(results.next());
129		assertEquals("The ID is wrong", 1, results.getInt("ID"));
130		assertTrue(results.next());
131		assertEquals("The ID is wrong", 2, results.getInt("ID"));
132		assertTrue(results.next());
133		assertEquals("The ID is wrong", 3, results.getInt("ID"));
134		assertTrue(results.next());
135		assertEquals("The ID is wrong", 4, results.getInt("ID"));
136		assertTrue(results.next());
137		assertEquals("The ID is wrong", 5, results.getInt("ID"));
138		assertTrue(results.next());
139		assertEquals("The ID is wrong", 6, results.getInt("ID"));
140		assertTrue(results.next());
141		assertEquals("The ID is wrong", 7, results.getInt("ID"));
142		assertTrue(results.next());
143		assertEquals("The ID is wrong", 8, results.getInt("ID"));
144		assertTrue(results.next());
145		assertEquals("The ID is wrong", 9, results.getInt("ID"));
146		assertTrue(results.next());
147		assertEquals("The ID is wrong", 41, results.getInt("ID"));
148		assertFalse(results.next());
	125
	126	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
	127
	128	Statement stmt = conn.createStatement();
	129
	130	ResultSet results = stmt
	131	.executeQuery("SELECT * FROM sample5 ORDER BY 1"))
	132	{
	133	assertTrue(results.next());
	134	assertEquals("The ID is wrong", 1, results.getInt("ID"));
	135	assertTrue(results.next());
	136	assertEquals("The ID is wrong", 2, results.getInt("ID"));
	137	assertTrue(results.next());
	138	assertEquals("The ID is wrong", 3, results.getInt("ID"));
	139	assertTrue(results.next());
	140	assertEquals("The ID is wrong", 4, results.getInt("ID"));
	141	assertTrue(results.next());
	142	assertEquals("The ID is wrong", 5, results.getInt("ID"));
	143	assertTrue(results.next());
	144	assertEquals("The ID is wrong", 6, results.getInt("ID"));
	145	assertTrue(results.next());
	146	assertEquals("The ID is wrong", 7, results.getInt("ID"));
	147	assertTrue(results.next());
	148	assertEquals("The ID is wrong", 8, results.getInt("ID"));
	149	assertTrue(results.next());
	150	assertEquals("The ID is wrong", 9, results.getInt("ID"));
	151	assertTrue(results.next());
	152	assertEquals("The ID is wrong", 41, results.getInt("ID"));
	153	assertFalse(results.next());
	154	}
149	155	}
150	156
151	157	@Test

153	159	{
154	160	Properties props = new Properties();
155	161	props.put("columnTypes", "Int,String,String,Timestamp");
156		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
157
158		Statement stmt = conn.createStatement();
159
160		ResultSet results = stmt
161		.executeQuery("SELECT ID+10 AS ID10 FROM sample5 ORDER BY 1");
162		assertTrue(results.next());
163		assertEquals("The ID is wrong", 11, results.getInt("ID10"));
164		assertTrue(results.next());
165		assertEquals("The ID is wrong", 12, results.getInt("ID10"));
166		assertTrue(results.next());
	162
	163	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
	164
	165	Statement stmt = conn.createStatement();
	166
	167	ResultSet results = stmt
	168	.executeQuery("SELECT ID+10 AS ID10 FROM sample5 ORDER BY 1"))
	169	{
	170	assertTrue(results.next());
	171	assertEquals("The ID is wrong", 11, results.getInt("ID10"));
	172	assertTrue(results.next());
	173	assertEquals("The ID is wrong", 12, results.getInt("ID10"));
	174	assertTrue(results.next());
	175	}
167	176	}
168	177
169	178	@Test

175	184	props.put("fileExtension", ".txt");
176	185	props.put("commentChar", "#");
177	186	props.put("columnTypes", "Integer,String");
178		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
179
180		Statement stmt = conn.createStatement();
181
182		ResultSet results = stmt
183		.executeQuery("SELECT BLZ FROM banks ORDER BY BLZ DESC");
184		assertTrue(results.next());
185		assertEquals("The BLZ is wrong", 10020500, results.getInt(1));
186		assertTrue(results.next());
187		assertEquals("The BLZ is wrong", 10020400, results.getInt(1));
188		assertTrue(results.next());
189		assertEquals("The BLZ is wrong", 10020200, results.getInt(1));
190		assertTrue(results.next());
191		assertEquals("The BLZ is wrong", 10020000, results.getInt(1));
192		assertTrue(results.next());
193		assertEquals("The BLZ is wrong", 10019610, results.getInt(1));
194		assertTrue(results.next());
195		assertEquals("The BLZ is wrong", 10010424, results.getInt(1));
196		assertTrue(results.next());
197		assertEquals("The BLZ is wrong", 10010222, results.getInt(1));
198		assertTrue(results.next());
199		assertEquals("The BLZ is wrong", 10010111, results.getInt(1));
200		assertTrue(results.next());
201		assertEquals("The BLZ is wrong", 10010010, results.getInt(1));
202		assertTrue(results.next());
203		assertEquals("The BLZ is wrong", 10000000, results.getInt(1));
204		assertFalse(results.next());
	187
	188	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
	189
	190	Statement stmt = conn.createStatement();
	191
	192	ResultSet results = stmt
	193	.executeQuery("SELECT BLZ FROM banks ORDER BY BLZ DESC"))
	194	{
	195	assertTrue(results.next());
	196	assertEquals("The BLZ is wrong", 10020500, results.getInt(1));
	197	assertTrue(results.next());
	198	assertEquals("The BLZ is wrong", 10020400, results.getInt(1));
	199	assertTrue(results.next());
	200	assertEquals("The BLZ is wrong", 10020200, results.getInt(1));
	201	assertTrue(results.next());
	202	assertEquals("The BLZ is wrong", 10020000, results.getInt(1));
	203	assertTrue(results.next());
	204	assertEquals("The BLZ is wrong", 10019610, results.getInt(1));
	205	assertTrue(results.next());
	206	assertEquals("The BLZ is wrong", 10010424, results.getInt(1));
	207	assertTrue(results.next());
	208	assertEquals("The BLZ is wrong", 10010222, results.getInt(1));
	209	assertTrue(results.next());
	210	assertEquals("The BLZ is wrong", 10010111, results.getInt(1));
	211	assertTrue(results.next());
	212	assertEquals("The BLZ is wrong", 10010010, results.getInt(1));
	213	assertTrue(results.next());
	214	assertEquals("The BLZ is wrong", 10000000, results.getInt(1));
	215	assertFalse(results.next());
	216	}
205	217	}
206	218
207	219	@Test

213	225	props.put("fileExtension", ".txt");
214	226	props.put("commentChar", "#");
215	227	props.put("columnTypes", "Date,Integer,Integer,Integer,Integer,Double");
216		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
217
218		Statement stmt = conn.createStatement();
219
220		ResultSet results = stmt
221		.executeQuery("select * from transactions order by from_blz, from_acct");
222		assertTrue(results.next());
223		assertEquals("The from_blz is wrong", 10010010, results.getInt("from_blz"));
224		assertEquals("The from_acct is wrong", 3670345, results.getInt("from_acct"));
225		assertTrue(results.next());
226		assertEquals("The from_blz is wrong", 10010010, results.getInt("from_blz"));
227		assertEquals("The from_acct is wrong", 3670345, results.getInt("from_acct"));
228		assertTrue(results.next());
229		assertEquals("The from_blz is wrong", 10010010, results.getInt("from_blz"));
230		assertEquals("The from_acct is wrong", 3670345, results.getInt("from_acct"));
231		assertTrue(results.next());
232		assertEquals("The from_blz is wrong", 10010010, results.getInt("from_blz"));
233		assertEquals("The from_acct is wrong", 3670345, results.getInt("from_acct"));
234		assertTrue(results.next());
235		assertEquals("The from_blz is wrong", 10010010, results.getInt("from_blz"));
236		assertEquals("The from_acct is wrong", 58340576, results.getInt("from_acct"));
237		assertTrue(results.next());
238		assertEquals("The from_blz is wrong", 10020200, results.getInt("from_blz"));
239		assertEquals("The from_acct is wrong", 2340529, results.getInt("from_acct"));
240		assertTrue(results.next());
241		assertEquals("The from_blz is wrong", 10020500, results.getInt("from_blz"));
242		assertEquals("The from_acct is wrong", 97540210, results.getInt("from_acct"));
243		assertTrue(results.next());
244		assertEquals("The from_blz is wrong", 10020500, results.getInt("from_blz"));
245		assertEquals("The from_acct is wrong", 97540210, results.getInt("from_acct"));
246		assertTrue(results.next());
247		assertEquals("The from_blz is wrong", 10020500, results.getInt("from_blz"));
248		assertEquals("The from_acct is wrong", 97540210, results.getInt("from_acct"));
249		assertFalse(results.next());
	228
	229	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
	230
	231	Statement stmt = conn.createStatement();
	232
	233	ResultSet results = stmt
	234	.executeQuery("select * from transactions order by from_blz, from_acct"))
	235	{
	236	assertTrue(results.next());
	237	assertEquals("The from_blz is wrong", 10010010, results.getInt("from_blz"));
	238	assertEquals("The from_acct is wrong", 3670345, results.getInt("from_acct"));
	239	assertTrue(results.next());
	240	assertEquals("The from_blz is wrong", 10010010, results.getInt("from_blz"));
	241	assertEquals("The from_acct is wrong", 3670345, results.getInt("from_acct"));
	242	assertTrue(results.next());
	243	assertEquals("The from_blz is wrong", 10010010, results.getInt("from_blz"));
	244	assertEquals("The from_acct is wrong", 3670345, results.getInt("from_acct"));
	245	assertTrue(results.next());
	246	assertEquals("The from_blz is wrong", 10010010, results.getInt("from_blz"));
	247	assertEquals("The from_acct is wrong", 3670345, results.getInt("from_acct"));
	248	assertTrue(results.next());
	249	assertEquals("The from_blz is wrong", 10010010, results.getInt("from_blz"));
	250	assertEquals("The from_acct is wrong", 58340576, results.getInt("from_acct"));
	251	assertTrue(results.next());
	252	assertEquals("The from_blz is wrong", 10020200, results.getInt("from_blz"));
	253	assertEquals("The from_acct is wrong", 2340529, results.getInt("from_acct"));
	254	assertTrue(results.next());
	255	assertEquals("The from_blz is wrong", 10020500, results.getInt("from_blz"));
	256	assertEquals("The from_acct is wrong", 97540210, results.getInt("from_acct"));
	257	assertTrue(results.next());
	258	assertEquals("The from_blz is wrong", 10020500, results.getInt("from_blz"));
	259	assertEquals("The from_acct is wrong", 97540210, results.getInt("from_acct"));
	260	assertTrue(results.next());
	261	assertEquals("The from_blz is wrong", 10020500, results.getInt("from_blz"));
	262	assertEquals("The from_acct is wrong", 97540210, results.getInt("from_acct"));
	263	assertFalse(results.next());
	264	}
250	265	}
251	266
252	267	@Test

258	273	props.put("fileExtension", ".txt");
259	274	props.put("commentChar", "#");
260	275	props.put("columnTypes", "Date,Integer,Integer,Integer,Integer,Double");
261		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
262
263		Statement stmt = conn.createStatement();
264
265		ResultSet results = stmt
266		.executeQuery("SELECT FROM_ACCT, FROM_BLZ from transactions where AMOUNT < 50 ORDER BY AMOUNT");
267		assertTrue(results.next());
268		assertEquals("The FROM_ACCT is wrong", 97540210, results.getInt("FROM_ACCT"));
269		assertEquals("The FROM_BLZ is wrong", 10020500, results.getInt("FROM_BLZ"));
270		assertTrue(results.next());
271		assertEquals("The FROM_ACCT is wrong", 3670345, results.getInt("FROM_ACCT"));
272		assertEquals("The FROM_BLZ is wrong", 10010010, results.getInt("FROM_BLZ"));
273		assertTrue(results.next());
274		assertEquals("The FROM_ACCT is wrong", 3670345, results.getInt("FROM_ACCT"));
275		assertEquals("The FROM_BLZ is wrong", 10010010, results.getInt("FROM_BLZ"));
276		assertFalse(results.next());
	276
	277	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
	278
	279	Statement stmt = conn.createStatement();
	280
	281	ResultSet results = stmt
	282	.executeQuery("SELECT FROM_ACCT, FROM_BLZ from transactions where AMOUNT < 50 ORDER BY AMOUNT"))
	283	{
	284	assertTrue(results.next());
	285	assertEquals("The FROM_ACCT is wrong", 97540210, results.getInt("FROM_ACCT"));
	286	assertEquals("The FROM_BLZ is wrong", 10020500, results.getInt("FROM_BLZ"));
	287	assertTrue(results.next());
	288	assertEquals("The FROM_ACCT is wrong", 3670345, results.getInt("FROM_ACCT"));
	289	assertEquals("The FROM_BLZ is wrong", 10010010, results.getInt("FROM_BLZ"));
	290	assertTrue(results.next());
	291	assertEquals("The FROM_ACCT is wrong", 3670345, results.getInt("FROM_ACCT"));
	292	assertEquals("The FROM_BLZ is wrong", 10010010, results.getInt("FROM_BLZ"));
	293	assertFalse(results.next());
	294	}
277	295	}
278	296
279	297	/**

293	311	props.put("fileExtension", ".txt");
294	312	props.put("commentChar", "#");
295	313	props.put("columnTypes", "Date,Integer,Integer,Integer,Integer,Double");
296		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
297
298		Statement stmt = conn.createStatement();
299
300		ResultSet results = stmt
301		.executeQuery("SELECT FROM_ACCT, AMOUNT * 0.01 as FEE from transactions ORDER BY FEE");
302		assertTrue(results.next());
303		assertEquals("The FROM_ACCT is wrong", 97540210, results.getInt(1));
304		double fee = results.getDouble(2);
305		assertTrue("The FEE is wrong", fuzzyEquals(7.23 * 0.01, fee));
306		assertTrue(results.next());
307		assertEquals("The FROM_ACCT is wrong", 3670345, results.getInt(1));
308		fee = results.getDouble(2);
309		assertTrue("The FEE is wrong", fuzzyEquals(21.23 * 0.01, fee));
	314
	315	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
	316
	317	Statement stmt = conn.createStatement();
	318
	319	ResultSet results = stmt
	320	.executeQuery("SELECT FROM_ACCT, AMOUNT * 0.01 as FEE from transactions ORDER BY FEE"))
	321	{
	322	assertTrue(results.next());
	323	assertEquals("The FROM_ACCT is wrong", 97540210, results.getInt(1));
	324	double fee = results.getDouble(2);
	325	assertTrue("The FEE is wrong", fuzzyEquals(7.23 * 0.01, fee));
	326	assertTrue(results.next());
	327	assertEquals("The FROM_ACCT is wrong", 3670345, results.getInt(1));
	328	fee = results.getDouble(2);
	329	assertTrue("The FEE is wrong", fuzzyEquals(21.23 * 0.01, fee));
	330	}
310	331	}
311	332
312	333	@Test

318	339	props.put("fileTailParts", "location,file_date");
319	340	props.put("indexedFiles", "True");
320	341	props.put("columnTypes", "Date,Time,String,Float,Float,String,String");
321		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
322
323		Statement stmt = conn.createStatement();
324
325		ResultSet results = stmt
326		.executeQuery("SELECT AI007.000, AI007.001 FROM test ORDER BY AI007.000 + AI007.001 DESC");
327		assertTrue(results.next());
328		double a0 = results.getFloat("AI007.000");
329		double a1 = results.getFloat("AI007.001");
330		assertTrue("The sort order is wrong", fuzzyEquals(26.54, a0 + a1));
331		assertTrue(results.next());
332		a0 = results.getFloat("AI007.000");
333		a1 = results.getFloat("AI007.001");
334		assertTrue("The sort order is wrong", fuzzyEquals(26.54, a0 + a1));
	342
	343	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
	344
	345	Statement stmt = conn.createStatement();
	346
	347	ResultSet results = stmt
	348	.executeQuery("SELECT AI007.000, AI007.001 FROM test ORDER BY AI007.000 + AI007.001 DESC"))
	349	{
	350	assertTrue(results.next());
	351	double a0 = results.getFloat("AI007.000");
	352	double a1 = results.getFloat("AI007.001");
	353	assertTrue("The sort order is wrong", fuzzyEquals(26.54, a0 + a1));
	354	assertTrue(results.next());
	355	a0 = results.getFloat("AI007.000");
	356	a1 = results.getFloat("AI007.001");
	357	assertTrue("The sort order is wrong", fuzzyEquals(26.54, a0 + a1));
	358	}
335	359	}
336	360
337	361	@Test

341	365	props.put("columnTypes", "Int,String,String,Date,Time");
342	366	props.put("timeFormat", "HHmm");
343	367	props.put("dateFormat", "yyyy-MM-dd");
344		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
345
346		Statement stmt = conn.createStatement();
347
348		ResultSet results = stmt
349		.executeQuery("select * from sample5 order by start+timeoffset asc");
350		assertTrue(results.next());
351		assertEquals("The ID is wrong", 1, results.getInt(1));
352		assertTrue(results.next());
353		assertEquals("The ID is wrong", 41, results.getInt(1));
354		assertTrue(results.next());
355		assertEquals("The ID is wrong", 2, results.getInt(1));
356		assertTrue(results.next());
357		assertEquals("The ID is wrong", 3, results.getInt(1));
358		assertTrue(results.next());
359		assertEquals("The ID is wrong", 7, results.getInt(1));
360		assertTrue(results.next());
361		assertEquals("The ID is wrong", 8, results.getInt(1));
362		assertTrue(results.next());
363		assertEquals("The ID is wrong", 4, results.getInt(1));
364		assertTrue(results.next());
365		assertEquals("The ID is wrong", 5, results.getInt(1));
366		assertTrue(results.next());
367		assertEquals("The ID is wrong", 6, results.getInt(1));
368		assertTrue(results.next());
369		assertEquals("The ID is wrong", 9, results.getInt(1));
370		assertFalse(results.next());
	368
	369	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
	370
	371	Statement stmt = conn.createStatement();
	372
	373	ResultSet results = stmt
	374	.executeQuery("select * from sample5 order by start+timeoffset asc"))
	375	{
	376	assertTrue(results.next());
	377	assertEquals("The ID is wrong", 1, results.getInt(1));
	378	assertTrue(results.next());
	379	assertEquals("The ID is wrong", 41, results.getInt(1));
	380	assertTrue(results.next());
	381	assertEquals("The ID is wrong", 2, results.getInt(1));
	382	assertTrue(results.next());
	383	assertEquals("The ID is wrong", 3, results.getInt(1));
	384	assertTrue(results.next());
	385	assertEquals("The ID is wrong", 7, results.getInt(1));
	386	assertTrue(results.next());
	387	assertEquals("The ID is wrong", 8, results.getInt(1));
	388	assertTrue(results.next());
	389	assertEquals("The ID is wrong", 4, results.getInt(1));
	390	assertTrue(results.next());
	391	assertEquals("The ID is wrong", 5, results.getInt(1));
	392	assertTrue(results.next());
	393	assertEquals("The ID is wrong", 6, results.getInt(1));
	394	assertTrue(results.next());
	395	assertEquals("The ID is wrong", 9, results.getInt(1));
	396	assertFalse(results.next());
	397	}
371	398	}
372	399
373	400	@Test
374	401	public void testOrderByWithBadColumnName() throws SQLException
375		{
376		try
377		{
378		Properties props = new Properties();
379		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
380
381		Statement stmt = conn.createStatement();
382
	402	{
	403	Properties props = new Properties();
	404
	405	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
	406
	407	Statement stmt = conn.createStatement())
	408	{
383	409	stmt.executeQuery("SELECT Id FROM sample order by XXXX");
384	410	fail("Should raise a java.sqlSQLException");
385	411	}

391	417
392	418	@Test
393	419	public void testOrderByWithBadColumnNumber() throws SQLException
394		{
395		try
396		{
397		Properties props = new Properties();
398		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
399
400		Statement stmt = conn.createStatement();
401
	420	{
	421	Properties props = new Properties();
	422
	423	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
	424
	425	Statement stmt = conn.createStatement())
	426	{
402	427	stmt.executeQuery("SELECT * FROM sample ORDER BY 99");
403	428	fail("Should raise a java.sqlSQLException");
404	429	}

410	435
411	436	@Test
412	437	public void testOrderByWithFloatColumnNumber() throws SQLException
413		{
414		try
415		{
416		Properties props = new Properties();
417		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
418
419		Statement stmt = conn.createStatement();
420
	438	{
	439	Properties props = new Properties();
	440
	441	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
	442
	443	Statement stmt = conn.createStatement())
	444	{
421	445	stmt.executeQuery("SELECT * FROM sample ORDER BY 3.14");
422	446	fail("Should raise a java.sqlSQLException");
423	447	}

429	453
430	454	@Test
431	455	public void testOrderByWithBadValue() throws SQLException
432		{
433		try
434		{
435		Properties props = new Properties();
436		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
437
438		Statement stmt = conn.createStatement();
439
	456	{
	457	Properties props = new Properties();
	458
	459	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
	460
	461	Statement stmt = conn.createStatement())
	462	{
440	463	stmt.executeQuery("SELECT * FROM sample ORDER BY 'X'");
441	464	fail("Should raise a java.sqlSQLException");
442	465	}

449	472	@Test
450	473	public void testOrderByNoResults() throws SQLException
451	474	{
452		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath);
453		Statement stmt = conn.createStatement();
454		ResultSet results = stmt
455		.executeQuery("SELECT Name, Job FROM sample4 WHERE ID='05' order by Name");
456		assertFalse(results.next());
	475	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath);
	476	Statement stmt = conn.createStatement();
	477	ResultSet results = stmt
	478	.executeQuery("SELECT Name, Job FROM sample4 WHERE ID='05' order by Name"))
	479	{
	480	assertFalse(results.next());
	481	}
457	482	}
458	483	}

+212

-184

src/test/java/org/relique/jdbc/csv/TestPrepareStatement.java less more

36	36
37	37	/**
38	38	* This class is used to test the CsvJdbc driver.
39		*
	39	*
40	40	* @author Mario Frasca
41	41	*/
42	42	public class TestPrepareStatement

67	67	{
68	68	Properties props = new Properties();
69	69	props.put("extension", ".csv");
70		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
71		+ filePath, props);
72
	70	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	71	+ filePath, props))
	72	{
	73	String queryString = "SELECT * FROM sample5 WHERE id BETWEEN ? AND ?";
	74	try
	75	{
	76	conn.prepareStatement(queryString);
	77	conn.prepareStatement(queryString, ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY);
	78	conn.prepareStatement(queryString, ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY,
	79	ResultSet.HOLD_CURSORS_OVER_COMMIT);
	80	}
	81	catch (UnsupportedOperationException e)
	82	{
	83	fail("cannot prepareStatement!");
	84	}
	85	}
	86	}
	87
	88	@Test
	89	public void testCanUsePreparedStatement() throws SQLException
	90	{
	91	Properties props = new Properties();
	92	props.put("extension", ".csv");
	93	props.put("columnTypes", "Int,String,String,Timestamp,String");
73	94	String queryString = "SELECT * FROM sample5 WHERE id BETWEEN ? AND ?";
74		try
75		{
76		conn.prepareStatement(queryString);
77		conn.prepareStatement(queryString, ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY);
78		conn.prepareStatement(queryString, ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY,
79		ResultSet.HOLD_CURSORS_OVER_COMMIT);
80		}
81		catch (UnsupportedOperationException e)
82		{
83		fail("cannot prepareStatement!");
84		}
85		}
86
87		@Test
88		public void testCanUsePreparedStatement() throws SQLException
89		{
90		Properties props = new Properties();
91		props.put("extension", ".csv");
92		props.put("columnTypes", "Int,String,String,Timestamp,String");
93		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
94		String queryString = "SELECT * FROM sample5 WHERE id BETWEEN ? AND ?";
95		PreparedStatement prepstmt = conn.prepareStatement(queryString);
96
97		prepstmt.setInt(1, 1);
98		prepstmt.setInt(2, 3);
99		ResultSet results = prepstmt.executeQuery();
100
101		assertTrue(results.next());
102		assertEquals("Integer column ID is wrong", new Integer(1), results.getObject("id"));
103		assertTrue(results.next());
104		assertEquals("Integer column ID is wrong", new Integer(2), results.getObject("id"));
105		assertTrue(results.next());
106		assertEquals("Integer column ID is wrong", new Integer(3), results.getObject("id"));
107		assertFalse(results.next());
	95	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
	96	PreparedStatement prepstmt = conn.prepareStatement(queryString))
	97	{
	98	prepstmt.setInt(1, 1);
	99	prepstmt.setInt(2, 3);
	100	try (ResultSet results = prepstmt.executeQuery())
	101	{
	102	assertTrue(results.next());
	103	assertEquals("Integer column ID is wrong", Integer.valueOf(1), results.getObject("id"));
	104	assertTrue(results.next());
	105	assertEquals("Integer column ID is wrong", Integer.valueOf(2), results.getObject("id"));
	106	assertTrue(results.next());
	107	assertEquals("Integer column ID is wrong", Integer.valueOf(3), results.getObject("id"));
	108	assertFalse(results.next());
	109	}
	110	}
108	111	}
109	112
110	113	@Test
111	114	public void testPreparedStatementIsClosed() throws SQLException
112	115	{
113		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath);
114	116	String queryString = "SELECT * FROM sample WHERE id = ?";
115		PreparedStatement prepstmt = conn.prepareStatement(queryString);
116
117		prepstmt.setString(1, "A123");
118		ResultSet results = prepstmt.executeQuery();
119
120		assertTrue(results.next());
121		assertEquals("Column EXTRA_FIELD is wrong", "A", results.getString("EXTRA_FIELD"));
122		conn.close();
123		assertTrue(prepstmt.isClosed());
124
	117	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath);
	118	PreparedStatement prepstmt = conn.prepareStatement(queryString))
	119	{
	120	prepstmt.setString(1, "A123");
	121	try (ResultSet results = prepstmt.executeQuery())
	122	{
	123	assertTrue(results.next());
	124	assertEquals("Column EXTRA_FIELD is wrong", "A", results.getString("EXTRA_FIELD"));
	125	conn.close();
	126	assertTrue(prepstmt.isClosed());
	127	}
	128	}
125	129	}
126	130
127	131	@Test

130	134	Properties props = new Properties();
131	135	props.put("extension", ".csv");
132	136	props.put("columnTypes", "Short,String,String");
133		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
134	137	String queryString = "SELECT * FROM sample4 WHERE id = ?";
135		PreparedStatement prepstmt = conn.prepareStatement(queryString);
136
137		prepstmt.setShort(1, (short)3);
138		ResultSet results = prepstmt.executeQuery();
139
140		assertTrue(results.next());
141		assertEquals("Column Job is wrong", "Finance Manager", results.getString("Job"));
142		assertFalse(results.next());
	138	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
	139	PreparedStatement prepstmt = conn.prepareStatement(queryString))
	140	{
	141	prepstmt.setShort(1, (short)3);
	142	try (ResultSet results = prepstmt.executeQuery())
	143	{
	144	assertTrue(results.next());
	145	assertEquals("Column Job is wrong", "Finance Manager", results.getString("Job"));
	146	assertFalse(results.next());
	147	}
	148	}
143	149	}
144	150
145	151	@Test

151	157	props.put("fileExtension", ".txt");
152	158	props.put("commentChar", "#");
153	159	props.put("columnTypes", "Long,String");
154		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	160	String queryString = "SELECT * FROM banks WHERE BLZ = ?";
	161	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
155	162	+ filePath, props);
156		String queryString = "SELECT * FROM banks WHERE BLZ = ?";
157		PreparedStatement prepstmt = conn.prepareStatement(queryString);
158
159		long blz = 10020200;
160		prepstmt.setLong(1, blz);
161		ResultSet results = prepstmt.executeQuery();
162
163		assertTrue(results.next());
164		assertEquals("Column BANK_NAME is wrong", "BHF-BANK (Berlin)", results.getString("BANK_NAME"));
165		assertFalse(results.next());
	163	PreparedStatement prepstmt = conn.prepareStatement(queryString))
	164	{
	165	long blz = 10020200;
	166	prepstmt.setLong(1, blz);
	167	ResultSet results = prepstmt.executeQuery();
	168
	169	assertTrue(results.next());
	170	assertEquals("Column BANK_NAME is wrong", "BHF-BANK (Berlin)", results.getString("BANK_NAME"));
	171	assertFalse(results.next());
	172	}
166	173	}
167	174
168	175	@Test

170	177	{
171	178	Properties props = new Properties();
172	179	props.put("columnTypes", "Byte,Short,Integer,Long,Float,Double,BigDecimal");
173		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
174	180	String queryString = "SELECT * FROM numeric WHERE C5 < ?";
175		PreparedStatement prepstmt = conn.prepareStatement(queryString);
176
177		prepstmt.setFloat(1, (float)3);
178		ResultSet results = prepstmt.executeQuery();
179
180		assertTrue(results.next());
181		assertEquals("Column C5 is wrong", "0.0", results.getString("C5"));
182		assertFalse(results.next());
	181	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
	182	PreparedStatement prepstmt = conn.prepareStatement(queryString))
	183	{
	184	prepstmt.setFloat(1, (float)3);
	185	try (ResultSet results = prepstmt.executeQuery())
	186	{
	187	assertTrue(results.next());
	188	assertEquals("Column C5 is wrong", "0.0", results.getString("C5"));
	189	assertFalse(results.next());
	190	}
	191	}
183	192	}
184	193
185	194	@Test

187	196	{
188	197	Properties props = new Properties();
189	198	props.put("columnTypes", "Byte,Short,Integer,Long,Float,Double,BigDecimal");
190		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
191	199	String queryString = "SELECT * FROM numeric WHERE C6 < ?";
192		PreparedStatement prepstmt = conn.prepareStatement(queryString);
193
194		prepstmt.setDouble(1, 1000.0);
195		ResultSet results = prepstmt.executeQuery();
196
197		assertTrue(results.next());
198		assertEquals("Column C6 is wrong", "-0.0", results.getString("C6"));
199		assertFalse(results.next());
	200	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
	201	PreparedStatement prepstmt = conn.prepareStatement(queryString))
	202	{
	203	prepstmt.setDouble(1, 1000.0);
	204	try (ResultSet results = prepstmt.executeQuery())
	205	{
	206	assertTrue(results.next());
	207	assertEquals("Column C6 is wrong", "-0.0", results.getString("C6"));
	208	assertFalse(results.next());
	209	}
	210	}
200	211	}
201	212
202	213	@Test

204	215	{
205	216	Properties props = new Properties();
206	217	props.put("columnTypes", "Int,String,String,Timestamp,String");
207		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
208	218	String queryString = "SELECT * FROM sample5 WHERE Name LIKE ?";
209		PreparedStatement prepstmt = conn.prepareStatement(queryString);
210
211		prepstmt.setString(1, "%Lucero%");
212		ResultSet results = prepstmt.executeQuery();
213
214		assertTrue(results.next());
215		assertEquals("Column ID is wrong", 3, results.getInt("ID"));
216		assertFalse(results.next());
	219	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
	220	PreparedStatement prepstmt = conn.prepareStatement(queryString))
	221	{
	222	prepstmt.setString(1, "%Lucero%");
	223	try (ResultSet results = prepstmt.executeQuery())
	224	{
	225	assertTrue(results.next());
	226	assertEquals("Column ID is wrong", 3, results.getInt("ID"));
	227	assertFalse(results.next());
	228	}
	229	}
217	230	}
218	231
219	232	@Test

222	235	Properties props = new Properties();
223	236	props.put("extension", ".csv");
224	237	props.put("columnTypes", "Int,String,String,Timestamp,String");
225		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
226	238	String queryString = "SELECT * FROM sample5 WHERE id BETWEEN ? AND ?";
227		PreparedStatement prepstmt = conn.prepareStatement(queryString);
228
229		prepstmt.setInt(1, 1);
230		prepstmt.setInt(2, 3);
231		ResultSet results1 = prepstmt.executeQuery();
232
233		assertTrue(results1.next());
234		assertTrue(results1.next());
235		assertTrue(results1.next());
236		assertFalse(results1.next());
237
238		prepstmt.setInt(1, 30);
239		prepstmt.setInt(2, 50);
240		ResultSet results2 = prepstmt.executeQuery();
241
242		assertTrue(results1.isClosed());
243		assertTrue(results2.next());
244		assertEquals("Integer column ID is wrong", new Integer(41), results2.getObject("id"));
245		assertFalse(results2.next());
	239	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
	240	PreparedStatement prepstmt = conn.prepareStatement(queryString))
	241	{
	242	prepstmt.setInt(1, 1);
	243	prepstmt.setInt(2, 3);
	244	try (ResultSet results1 = prepstmt.executeQuery())
	245	{
	246	assertTrue(results1.next());
	247	assertTrue(results1.next());
	248	assertTrue(results1.next());
	249	assertFalse(results1.next());
	250
	251	prepstmt.setInt(1, 30);
	252	prepstmt.setInt(2, 50);
	253	try (ResultSet results2 = prepstmt.executeQuery())
	254	{
	255	assertTrue(results1.isClosed());
	256	assertTrue(results2.next());
	257	assertEquals("Integer column ID is wrong", Integer.valueOf(41), results2.getObject("id"));
	258	assertFalse(results2.next());
	259	}
	260	}
	261	}
246	262	}
247	263
248	264	@Test

251	267	Properties props = new Properties();
252	268	props.put("extension", ".csv");
253	269	props.put("columnTypes", "Int,String,String,Timestamp,String");
254		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
255	270	String queryString = "SELECT * FROM sample5 WHERE job = ?";
256		PreparedStatement prepstmt = conn.prepareStatement(queryString);
257
258		prepstmt.setString(1, "Project Manager");
259		ResultSet results = prepstmt.executeQuery();
260
261		assertTrue(results.next());
262		assertEquals("Integer column ID is wrong", new Integer(1), results.getObject("id"));
263		assertTrue(results.next());
264		assertEquals("Integer column ID is wrong", new Integer(3), results.getObject("id"));
265		assertTrue(results.next());
266		assertEquals("Integer column ID is wrong", new Integer(4), results.getObject("id"));
267		assertFalse(results.next());
268
269		prepstmt.setString(1, "Office Employee");
270		results = prepstmt.executeQuery();
271
272		assertTrue(results.next());
273		assertEquals("Integer column ID is wrong", new Integer(6), results.getObject("id"));
274		assertTrue(results.next());
275		assertEquals("Integer column ID is wrong", new Integer(7), results.getObject("id"));
276		assertTrue(results.next());
277		assertEquals("Integer column ID is wrong", new Integer(8), results.getObject("id"));
278		assertTrue(results.next());
279		assertEquals("Integer column ID is wrong", new Integer(9), results.getObject("id"));
280		assertFalse(results.next());
	271	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
	272	PreparedStatement prepstmt = conn.prepareStatement(queryString))
	273	{
	274	prepstmt.setString(1, "Project Manager");
	275	try (ResultSet results = prepstmt.executeQuery())
	276	{
	277	assertTrue(results.next());
	278	assertEquals("Integer column ID is wrong", Integer.valueOf(1), results.getObject("id"));
	279	assertTrue(results.next());
	280	assertEquals("Integer column ID is wrong", Integer.valueOf(3), results.getObject("id"));
	281	assertTrue(results.next());
	282	assertEquals("Integer column ID is wrong", Integer.valueOf(4), results.getObject("id"));
	283	assertFalse(results.next());
	284	}
	285
	286	prepstmt.setString(1, "Office Employee");
	287	try (ResultSet results = prepstmt.executeQuery())
	288	{
	289	assertTrue(results.next());
	290	assertEquals("Integer column ID is wrong", Integer.valueOf(6), results.getObject("id"));
	291	assertTrue(results.next());
	292	assertEquals("Integer column ID is wrong", Integer.valueOf(7), results.getObject("id"));
	293	assertTrue(results.next());
	294	assertEquals("Integer column ID is wrong", Integer.valueOf(8), results.getObject("id"));
	295	assertTrue(results.next());
	296	assertEquals("Integer column ID is wrong", Integer.valueOf(9), results.getObject("id"));
	297	assertFalse(results.next());
	298	}
	299	}
281	300	}
282	301
283	302	@Test

285	304	{
286	305	Properties props = new Properties();
287	306	props.put("extension", ".csv");
288		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
289
290		String queryString = "SELECT * FROM sample5";
291		try
292		{
293		conn.prepareStatement(queryString);
294		}
295		catch (UnsupportedOperationException e)
296		{
297		fail("can't prepareStatement!");
	307	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props))
	308	{
	309	String queryString = "SELECT * FROM sample5";
	310	try
	311	{
	312	conn.prepareStatement(queryString);
	313	}
	314	catch (UnsupportedOperationException e)
	315	{
	316	fail("can't prepareStatement!");
	317	}
298	318	}
299	319	}
300	320
301	321	@Test
302	322	public void testTableReader() throws SQLException
303	323	{
304		Connection conn = DriverManager.getConnection("jdbc:relique:csv:class:" +
	324	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:class:" +
305	325	TableReaderTester.class.getName());
306		PreparedStatement stmt = conn.prepareStatement("SELECT * FROM airport where code=?");
307		stmt.setString(1, "CDG");
308		ResultSet results = stmt.executeQuery();
309		assertTrue(results.next());
310		assertEquals("NAME wrong", "Paris Charles De Gaulle", results.getString("NAME"));
311		assertFalse(results.next());
	326	PreparedStatement stmt = conn.prepareStatement("SELECT * FROM airport where code=?"))
	327	{
	328	stmt.setString(1, "CDG");
	329	try (ResultSet results = stmt.executeQuery())
	330	{
	331	assertTrue(results.next());
	332	assertEquals("NAME wrong", "Paris Charles De Gaulle", results.getString("NAME"));
	333	assertFalse(results.next());
	334	}
	335	}
312	336	}
313	337
314	338	@Test

317	341	Properties props = new Properties();
318	342	props.put("extension", ".csv");
319	343	props.put("columnTypes", "Int,String,String,Timestamp,String");
320		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
321	344	String queryString = "SELECT * FROM sample5 where id > ? order by id";
322		PreparedStatement prepstmt = conn.prepareStatement(queryString);
323
324		prepstmt.setInt(1, 7);
325		ResultSet results = prepstmt.executeQuery();
326		assertTrue(results.next());
327		assertEquals("column ID is wrong", 8, results.getInt("ID"));
328		assertTrue(results.next());
329		assertEquals("column ID is wrong", 9, results.getInt("ID"));
330		assertTrue(results.next());
331		assertEquals("column ID is wrong", 41, results.getInt("ID"));
332		assertFalse(results.next());
333		results.close();
	345	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
	346	PreparedStatement prepstmt = conn.prepareStatement(queryString))
	347	{
	348	prepstmt.setInt(1, 7);
	349	try (ResultSet results = prepstmt.executeQuery())
	350	{
	351	assertTrue(results.next());
	352	assertEquals("column ID is wrong", 8, results.getInt("ID"));
	353	assertTrue(results.next());
	354	assertEquals("column ID is wrong", 9, results.getInt("ID"));
	355	assertTrue(results.next());
	356	assertEquals("column ID is wrong", 41, results.getInt("ID"));
	357	assertFalse(results.next());
	358	}
	359	}
334	360	}
335	361
336	362	@Test

339	365	Properties props = new Properties();
340	366	props.put("extension", ".csv");
341	367	props.put("columnTypes", "Int,String,String,Timestamp,String");
342		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
343	368	String queryString = "SELECT * FROM sample5 where id = ?";
344		PreparedStatement prepstmt = conn.prepareStatement(queryString);
345
346		prepstmt.setInt(1, 2);
347		assertTrue(prepstmt.execute());
348		ResultSet results = prepstmt.getResultSet();
349		assertNotNull("ResultSet is null", results);
350		assertTrue(results.next());
351		assertEquals("column Job is wrong", "Finance Manager", results.getString("Job"));
352		assertFalse(results.next());
353		assertFalse(prepstmt.getMoreResults());
354		results.close();
	369	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
	370	PreparedStatement prepstmt = conn.prepareStatement(queryString))
	371	{
	372	prepstmt.setInt(1, 2);
	373	assertTrue(prepstmt.execute());
	374	try (ResultSet results = prepstmt.getResultSet())
	375	{
	376	assertNotNull("ResultSet is null", results);
	377	assertTrue(results.next());
	378	assertEquals("column Job is wrong", "Finance Manager", results.getString("Job"));
	379	assertFalse(results.next());
	380	assertFalse(prepstmt.getMoreResults());
	381	}
	382	}
355	383	}
356	384	}

+854

-882

src/test/java/org/relique/jdbc/csv/TestScrollableDriver.java less more

35	35
36	36	/**
37	37	* This class is used to test the CsvJdbc Scrollable driver.
38		*
	38	*
39	39	* @author Chetan Gupta
40	40	*/
41	41	public class TestScrollableDriver

66	66	{
67	67	// create a connection. The first command line parameter is assumed to
68	68	// be the directory in which the .csv files are held
69		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
70		+ filePath);
71
72		// create a Statement object to execute the query with
73		Statement stmt = conn.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE,
74		ResultSet.CONCUR_READ_ONLY);
75
76		// Select the ID and NAME columns from sample.csv
77		ResultSet results = stmt.executeQuery("SELECT ID,NAME FROM sample");
78
79		// dump out the results
80		results.next();
81		assertEquals("Incorrect ID Value", "Q123", results.getString("ID"));
82		assertEquals("Incorrect NAME Value", "\"S,\"", results
83		.getString("NAME"));
84		assertEquals("incorrect row #", 1, results.getRow());
85
86		results.next();
87		assertEquals("Incorrect ID Value", "A123", results.getString("ID"));
88		assertEquals("Incorrect NAME Value", "Jonathan Ackerman", results
89		.getString("NAME"));
90		assertEquals("incorrect row #", 2, results.getRow());
91
92		results.previous();
93		assertEquals("incorrect row #", 1, results.getRow());
94		assertEquals("Incorrect ID Value", "Q123", results.getString("ID"));
95		assertEquals("Incorrect NAME Value", "\"S,\"", results
96		.getString("NAME"));
97
98		results.first();
99		assertEquals("Incorrect ID Value", "Q123", results.getString("ID"));
100		assertEquals("Incorrect NAME Value", "\"S,\"", results
101		.getString("NAME"));
102		assertEquals("incorrect row #", 1, results.getRow());
103
104		assertFalse(results.previous());
105		assertEquals("incorrect row #", 0, results.getRow());
106		try
107		{
108		results.getString("ID");
109		fail("Should raise a java.sqlSQLException");
110		}
111		catch (SQLException e)
112		{
113		assertEquals("java.sql.SQLException: " + CsvResources.getString("noCurrentRow"), "" + e);
114		}
115		try
116		{
117		results.getString("NAME");
118		fail("Should raise a java.sqlSQLException");
119		}
120		catch (SQLException e)
121		{
122		assertEquals("java.sql.SQLException: " + CsvResources.getString("noCurrentRow"), "" + e);
123		}
124
125		results.next();
126		assertEquals("incorrect row #", 1, results.getRow());
127		assertEquals("Incorrect ID Value", "Q123", results.getString("ID"));
128		assertEquals("Incorrect NAME Value", "\"S,\"", results
129		.getString("NAME"));
130
131		results.next();
132		assertEquals("incorrect row #", 2, results.getRow());
133		assertEquals("Incorrect ID Value", "A123", results.getString("ID"));
134		assertEquals("Incorrect NAME Value", "Jonathan Ackerman", results
135		.getString("NAME"));
136
137		results.absolute(1);
138		assertEquals("incorrect row #", 1, results.getRow());
139		assertEquals("Incorrect ID Value", "Q123", results.getString("ID"));
140		assertEquals("Incorrect NAME Value", "\"S,\"", results
141		.getString("NAME"));
142
143		results.absolute(2);
144		assertEquals("incorrect row #", 2, results.getRow());
145		assertEquals("Incorrect ID Value", "A123", results.getString("ID"));
146		assertEquals("Incorrect NAME Value", "Jonathan Ackerman", results
147		.getString("NAME"));
148
149		results.relative(2);
150		assertEquals("incorrect row #", 4, results.getRow());
151		assertEquals("Incorrect ID Value", "C456", results.getString("ID"));
152		assertEquals("Incorrect NAME Value", "Susan, Peter and Dave", results
153		.getString("NAME"));
154
155		results.relative(-3);
156		assertEquals("incorrect row #", 1, results.getRow());
157		assertEquals("Incorrect ID Value", "Q123", results.getString("ID"));
158		assertEquals("Incorrect NAME Value", "\"S,\"", results
159		.getString("NAME"));
160
161		results.relative(0);
162		assertEquals("incorrect row #", 1, results.getRow());
163		assertEquals("Incorrect ID Value", "Q123", results.getString("ID"));
164		assertEquals("Incorrect NAME Value", results.getString("NAME"),
165		"\"S,\"");
166
167		results.last();
168		assertEquals("incorrect row #", 6, results.getRow());
169		assertEquals("Incorrect ID Value", "X234", results.getString("ID"));
170		assertEquals("Incorrect NAME Value",
171		"Peter \"peg leg\", Jimmy & Samantha \"Sam\"", results
172		.getString("NAME"));
173
174		results.absolute(-1);
175		assertEquals("incorrect row #", 6, results.getRow());
176		assertEquals("Incorrect ID Value", "X234", results.getString("ID"));
177		assertEquals("Incorrect NAME Value",
178		"Peter \"peg leg\", Jimmy & Samantha \"Sam\"", results
179		.getString("NAME"));
180
181		results.absolute(-2);
182		assertEquals("incorrect row #", 5, results.getRow());
183		assertEquals("Incorrect ID Value", "D789", results.getString("ID"));
184		assertEquals("Incorrect NAME Value", "Amelia \"meals\" Maurice",
185		results.getString("NAME"));
186
187		results.last();
188		results.next();
189		assertNull(results.getString("ID"));
190		assertNull(results.getString("NAME"));
191
192		results.previous();
193		assertEquals("Incorrect ID Value", "X234", results.getString("ID"));
194		assertEquals("Incorrect NAME Value",
195		"Peter \"peg leg\", Jimmy & Samantha \"Sam\"", results
196		.getString("NAME"));
197
198		assertFalse(results.relative(100));
199		assertEquals("incorrect row #", 7, results.getRow());
200		assertNull(results.getString("ID"));
201		assertNull(results.getString("NAME"));
202
203		assertFalse(results.relative(-100));
204		assertEquals("incorrect row #", 0, results.getRow());
205		try
206		{
207		results.getString("ID");
208		fail("Should raise a java.sqlSQLException");
209		}
210		catch (SQLException e)
211		{
212		assertEquals("java.sql.SQLException: " + CsvResources.getString("noCurrentRow"), "" + e);
213		}
214
215		try
216		{
217		results.getString("NAME");
218		fail("Should raise a java.sqlSQLException");
219		}
220		catch (SQLException e)
221		{
222		assertEquals("java.sql.SQLException: " + CsvResources.getString("noCurrentRow"), "" + e);
223		}
224
225		results.relative(2);
226		assertEquals("incorrect row #", 2, results.getRow());
227		assertEquals("Incorrect ID Value", results.getString("ID"), "A123");
228		assertEquals("Incorrect NAME Value", results.getString("NAME"),
229		"Jonathan Ackerman");
230
231		results.absolute(7);
232		assertEquals("incorrect row #", 7, results.getRow());
233		assertNull(results.getString("ID"));
234		assertNull(results.getString("NAME"));
235
236		assertFalse(results.absolute(-10));
237		assertEquals("incorrect row #", 0, results.getRow());
238		try
239		{
240		results.getString("ID");
241		fail("Should raise a java.sqlSQLException");
242		}
243		catch (SQLException e)
244		{
245		assertEquals("java.sql.SQLException: " + CsvResources.getString("noCurrentRow"), "" + e);
246		}
247
248		try
249		{
250		results.getString("NAME");
251		fail("Should raise a java.sqlSQLException");
252		}
253		catch (SQLException e)
254		{
255		assertEquals("java.sql.SQLException: " + CsvResources.getString("noCurrentRow"), "" + e);
256		}
257
258		results.absolute(2);
259		assertEquals("Incorrect ID Value", results.getString("ID"), "A123");
260		assertEquals("Incorrect NAME Value", results.getString("NAME"),
261		"Jonathan Ackerman");
262
263		assertFalse(results.absolute(0));
264		try
265		{
266		results.getString("ID");
267		fail("Should raise a java.sqlSQLException");
268		}
269		catch (SQLException e)
270		{
271		assertEquals("java.sql.SQLException: " + CsvResources.getString("noCurrentRow"), "" + e);
272		}
273
274		try
275		{
276		results.getString("NAME");
277		fail("Should raise a java.sqlSQLException");
278		}
279		catch (SQLException e)
280		{
281		assertEquals("java.sql.SQLException: " + CsvResources.getString("noCurrentRow"), "" + e);
282		}
283
284		assertFalse(results.relative(0));
285		try
286		{
287		results.getString("ID");
288		fail("Should raise a java.sqlSQLException");
289		}
290		catch (SQLException e)
291		{
292		assertEquals("java.sql.SQLException: " + CsvResources.getString("noCurrentRow"), "" + e);
293		}
294
295		try
296		{
297		results.getString("NAME");
298		fail("Should raise a java.sqlSQLException");
299		}
300		catch (SQLException e)
301		{
302		assertEquals("java.sql.SQLException: " + CsvResources.getString("noCurrentRow"), "" + e);
303		}
304
305		// clean up
306		results.close();
307		stmt.close();
308		conn.close();
309
	69	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	70	+ filePath);
	71
	72	// create a Statement object to execute the query with
	73	Statement stmt = conn.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE,
	74	ResultSet.CONCUR_READ_ONLY);
	75
	76	// Select the ID and NAME columns from sample.csv
	77	ResultSet results = stmt.executeQuery("SELECT ID,NAME FROM sample"))
	78	{
	79	// dump out the results
	80	results.next();
	81	assertEquals("Incorrect ID Value", "Q123", results.getString("ID"));
	82	assertEquals("Incorrect NAME Value", "\"S,\"", results
	83	.getString("NAME"));
	84	assertEquals("incorrect row #", 1, results.getRow());
	85
	86	results.next();
	87	assertEquals("Incorrect ID Value", "A123", results.getString("ID"));
	88	assertEquals("Incorrect NAME Value", "Jonathan Ackerman", results
	89	.getString("NAME"));
	90	assertEquals("incorrect row #", 2, results.getRow());
	91
	92	results.previous();
	93	assertEquals("incorrect row #", 1, results.getRow());
	94	assertEquals("Incorrect ID Value", "Q123", results.getString("ID"));
	95	assertEquals("Incorrect NAME Value", "\"S,\"", results
	96	.getString("NAME"));
	97
	98	results.first();
	99	assertEquals("Incorrect ID Value", "Q123", results.getString("ID"));
	100	assertEquals("Incorrect NAME Value", "\"S,\"", results
	101	.getString("NAME"));
	102	assertEquals("incorrect row #", 1, results.getRow());
	103
	104	assertFalse(results.previous());
	105	assertEquals("incorrect row #", 0, results.getRow());
	106	try
	107	{
	108	results.getString("ID");
	109	fail("Should raise a java.sqlSQLException");
	110	}
	111	catch (SQLException e)
	112	{
	113	assertEquals("java.sql.SQLException: " + CsvResources.getString("noCurrentRow"), "" + e);
	114	}
	115	try
	116	{
	117	results.getString("NAME");
	118	fail("Should raise a java.sqlSQLException");
	119	}
	120	catch (SQLException e)
	121	{
	122	assertEquals("java.sql.SQLException: " + CsvResources.getString("noCurrentRow"), "" + e);
	123	}
	124
	125	results.next();
	126	assertEquals("incorrect row #", 1, results.getRow());
	127	assertEquals("Incorrect ID Value", "Q123", results.getString("ID"));
	128	assertEquals("Incorrect NAME Value", "\"S,\"", results
	129	.getString("NAME"));
	130
	131	results.next();
	132	assertEquals("incorrect row #", 2, results.getRow());
	133	assertEquals("Incorrect ID Value", "A123", results.getString("ID"));
	134	assertEquals("Incorrect NAME Value", "Jonathan Ackerman", results
	135	.getString("NAME"));
	136
	137	results.absolute(1);
	138	assertEquals("incorrect row #", 1, results.getRow());
	139	assertEquals("Incorrect ID Value", "Q123", results.getString("ID"));
	140	assertEquals("Incorrect NAME Value", "\"S,\"", results
	141	.getString("NAME"));
	142
	143	results.absolute(2);
	144	assertEquals("incorrect row #", 2, results.getRow());
	145	assertEquals("Incorrect ID Value", "A123", results.getString("ID"));
	146	assertEquals("Incorrect NAME Value", "Jonathan Ackerman", results
	147	.getString("NAME"));
	148
	149	results.relative(2);
	150	assertEquals("incorrect row #", 4, results.getRow());
	151	assertEquals("Incorrect ID Value", "C456", results.getString("ID"));
	152	assertEquals("Incorrect NAME Value", "Susan, Peter and Dave", results
	153	.getString("NAME"));
	154
	155	results.relative(-3);
	156	assertEquals("incorrect row #", 1, results.getRow());
	157	assertEquals("Incorrect ID Value", "Q123", results.getString("ID"));
	158	assertEquals("Incorrect NAME Value", "\"S,\"", results
	159	.getString("NAME"));
	160
	161	results.relative(0);
	162	assertEquals("incorrect row #", 1, results.getRow());
	163	assertEquals("Incorrect ID Value", "Q123", results.getString("ID"));
	164	assertEquals("Incorrect NAME Value", results.getString("NAME"),
	165	"\"S,\"");
	166
	167	results.last();
	168	assertEquals("incorrect row #", 6, results.getRow());
	169	assertEquals("Incorrect ID Value", "X234", results.getString("ID"));
	170	assertEquals("Incorrect NAME Value",
	171	"Peter \"peg leg\", Jimmy & Samantha \"Sam\"", results
	172	.getString("NAME"));
	173
	174	results.absolute(-1);
	175	assertEquals("incorrect row #", 6, results.getRow());
	176	assertEquals("Incorrect ID Value", "X234", results.getString("ID"));
	177	assertEquals("Incorrect NAME Value",
	178	"Peter \"peg leg\", Jimmy & Samantha \"Sam\"", results
	179	.getString("NAME"));
	180
	181	results.absolute(-2);
	182	assertEquals("incorrect row #", 5, results.getRow());
	183	assertEquals("Incorrect ID Value", "D789", results.getString("ID"));
	184	assertEquals("Incorrect NAME Value", "Amelia \"meals\" Maurice",
	185	results.getString("NAME"));
	186
	187	results.last();
	188	results.next();
	189	assertNull(results.getString("ID"));
	190	assertNull(results.getString("NAME"));
	191
	192	results.previous();
	193	assertEquals("Incorrect ID Value", "X234", results.getString("ID"));
	194	assertEquals("Incorrect NAME Value",
	195	"Peter \"peg leg\", Jimmy & Samantha \"Sam\"", results
	196	.getString("NAME"));
	197
	198	assertFalse(results.relative(100));
	199	assertEquals("incorrect row #", 7, results.getRow());
	200	assertNull(results.getString("ID"));
	201	assertNull(results.getString("NAME"));
	202
	203	assertFalse(results.relative(-100));
	204	assertEquals("incorrect row #", 0, results.getRow());
	205	try
	206	{
	207	results.getString("ID");
	208	fail("Should raise a java.sqlSQLException");
	209	}
	210	catch (SQLException e)
	211	{
	212	assertEquals("java.sql.SQLException: " + CsvResources.getString("noCurrentRow"), "" + e);
	213	}
	214
	215	try
	216	{
	217	results.getString("NAME");
	218	fail("Should raise a java.sqlSQLException");
	219	}
	220	catch (SQLException e)
	221	{
	222	assertEquals("java.sql.SQLException: " + CsvResources.getString("noCurrentRow"), "" + e);
	223	}
	224
	225	results.relative(2);
	226	assertEquals("incorrect row #", 2, results.getRow());
	227	assertEquals("Incorrect ID Value", results.getString("ID"), "A123");
	228	assertEquals("Incorrect NAME Value", results.getString("NAME"),
	229	"Jonathan Ackerman");
	230
	231	results.absolute(7);
	232	assertEquals("incorrect row #", 7, results.getRow());
	233	assertNull(results.getString("ID"));
	234	assertNull(results.getString("NAME"));
	235
	236	assertFalse(results.absolute(-10));
	237	assertEquals("incorrect row #", 0, results.getRow());
	238	try
	239	{
	240	results.getString("ID");
	241	fail("Should raise a java.sqlSQLException");
	242	}
	243	catch (SQLException e)
	244	{
	245	assertEquals("java.sql.SQLException: " + CsvResources.getString("noCurrentRow"), "" + e);
	246	}
	247
	248	try
	249	{
	250	results.getString("NAME");
	251	fail("Should raise a java.sqlSQLException");
	252	}
	253	catch (SQLException e)
	254	{
	255	assertEquals("java.sql.SQLException: " + CsvResources.getString("noCurrentRow"), "" + e);
	256	}
	257
	258	results.absolute(2);
	259	assertEquals("Incorrect ID Value", results.getString("ID"), "A123");
	260	assertEquals("Incorrect NAME Value", results.getString("NAME"),
	261	"Jonathan Ackerman");
	262
	263	assertFalse(results.absolute(0));
	264	try
	265	{
	266	results.getString("ID");
	267	fail("Should raise a java.sqlSQLException");
	268	}
	269	catch (SQLException e)
	270	{
	271	assertEquals("java.sql.SQLException: " + CsvResources.getString("noCurrentRow"), "" + e);
	272	}
	273
	274	try
	275	{
	276	results.getString("NAME");
	277	fail("Should raise a java.sqlSQLException");
	278	}
	279	catch (SQLException e)
	280	{
	281	assertEquals("java.sql.SQLException: " + CsvResources.getString("noCurrentRow"), "" + e);
	282	}
	283
	284	assertFalse(results.relative(0));
	285	try
	286	{
	287	results.getString("ID");
	288	fail("Should raise a java.sqlSQLException");
	289	}
	290	catch (SQLException e)
	291	{
	292	assertEquals("java.sql.SQLException: " + CsvResources.getString("noCurrentRow"), "" + e);
	293	}
	294
	295	try
	296	{
	297	results.getString("NAME");
	298	fail("Should raise a java.sqlSQLException");
	299	}
	300	catch (SQLException e)
	301	{
	302	assertEquals("java.sql.SQLException: " + CsvResources.getString("noCurrentRow"), "" + e);
	303	}
	304	}
310	305	}
311	306
312	307	@Test

314	309	{
315	310	// create a connection. The first command line parameter is assumed to
316	311	// be the directory in which the .csv files are held
317		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
318		+ filePath);
319
320		// create a Statement object to execute the query with
321		Statement stmt = conn.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE,
322		ResultSet.CONCUR_READ_ONLY);
323
324		// Select the ID and NAME columns from sample.csv
325		ResultSet results = stmt.executeQuery("SELECT ID, NAME FROM sample");
326
327		// dump out the results
328		results.next();
329		assertEquals("incorrect row #", 1, results.getRow());
330		assertTrue(results.isFirst());
331		assertFalse(results.isLast());
332		assertFalse(results.isBeforeFirst());
333		assertFalse(results.isAfterLast());
334
335		results.next();
336		assertEquals("incorrect row #", 2, results.getRow());
337		assertFalse(results.isFirst());
338		assertFalse(results.isLast());
339
340		results.previous();
341		assertEquals("incorrect row #", 1, results.getRow());
342		assertTrue(results.isFirst());
343		assertFalse(results.isLast());
344
345		results.first();
346		assertEquals("incorrect row #", 1, results.getRow());
347		assertTrue(results.isFirst());
348		assertFalse(results.isLast());
349
350		results.previous();
351		assertEquals("incorrect row #", 0, results.getRow());
352		assertTrue(results.isBeforeFirst());
353		assertFalse(results.isAfterLast());
354		assertFalse(results.isFirst());
355		assertFalse(results.isLast());
356
357		results.next();
358		assertEquals("incorrect row #", 1, results.getRow());
359		assertTrue(results.isFirst());
360		assertFalse(results.isLast());
361
362		results.last();
363		assertEquals("incorrect row #", 6, results.getRow());
364		assertFalse(results.isFirst());
365		assertTrue(results.isLast());
366
367		results.absolute(-1);
368		assertEquals("incorrect row #", 6, results.getRow());
369		assertFalse(results.isBeforeFirst());
370		assertFalse(results.isAfterLast());
371		assertFalse(results.isFirst());
372		assertTrue(results.isLast());
373
374		results.afterLast();
375		assertEquals("incorrect row #", 7, results.getRow());
376		assertFalse(results.isBeforeFirst());
377		assertTrue(results.isAfterLast());
378		assertFalse("is seen as first", results.isFirst());
379		assertFalse("is seen as last", results.isLast());
380
381		// clean up
382		results.close();
383		stmt.close();
384		conn.close();
	312	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	313	+ filePath);
	314
	315	// create a Statement object to execute the query with
	316	Statement stmt = conn.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE,
	317	ResultSet.CONCUR_READ_ONLY);
	318
	319	// Select the ID and NAME columns from sample.csv
	320	ResultSet results = stmt.executeQuery("SELECT ID, NAME FROM sample"))
	321	{
	322	// dump out the results
	323	results.next();
	324	assertEquals("incorrect row #", 1, results.getRow());
	325	assertTrue(results.isFirst());
	326	assertFalse(results.isLast());
	327	assertFalse(results.isBeforeFirst());
	328	assertFalse(results.isAfterLast());
	329
	330	results.next();
	331	assertEquals("incorrect row #", 2, results.getRow());
	332	assertFalse(results.isFirst());
	333	assertFalse(results.isLast());
	334
	335	results.previous();
	336	assertEquals("incorrect row #", 1, results.getRow());
	337	assertTrue(results.isFirst());
	338	assertFalse(results.isLast());
	339
	340	results.first();
	341	assertEquals("incorrect row #", 1, results.getRow());
	342	assertTrue(results.isFirst());
	343	assertFalse(results.isLast());
	344
	345	results.previous();
	346	assertEquals("incorrect row #", 0, results.getRow());
	347	assertTrue(results.isBeforeFirst());
	348	assertFalse(results.isAfterLast());
	349	assertFalse(results.isFirst());
	350	assertFalse(results.isLast());
	351
	352	results.next();
	353	assertEquals("incorrect row #", 1, results.getRow());
	354	assertTrue(results.isFirst());
	355	assertFalse(results.isLast());
	356
	357	results.last();
	358	assertEquals("incorrect row #", 6, results.getRow());
	359	assertFalse(results.isFirst());
	360	assertTrue(results.isLast());
	361
	362	results.absolute(-1);
	363	assertEquals("incorrect row #", 6, results.getRow());
	364	assertFalse(results.isBeforeFirst());
	365	assertFalse(results.isAfterLast());
	366	assertFalse(results.isFirst());
	367	assertTrue(results.isLast());
	368
	369	results.afterLast();
	370	assertEquals("incorrect row #", 7, results.getRow());
	371	assertFalse(results.isBeforeFirst());
	372	assertTrue(results.isAfterLast());
	373	assertFalse("is seen as first", results.isFirst());
	374	assertFalse("is seen as last", results.isLast());
	375	}
385	376	}
386	377
387	378	@Test

393	384
394	385	// create a connection. The first command line parameter is assumed to
395	386	// be the directory in which the .csv files are held
396		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
397		+ filePath);
398
399		// create a Statement object to execute the query with
400		Statement stmt = conn.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE,
401		ResultSet.CONCUR_READ_ONLY);
402
403		// Select the ID and NAME columns from sample.csv
404		ResultSet results = stmt.executeQuery("SELECT ID,NAME FROM sample2");
405
406		// dump out the results
407		results.next();
408		assertEquals("Incorrect ID Value", "A123", results.getString("ID"));
409		assertEquals("Incorrect NAME Value", "Aman", results.getString("NAME"));
410
411		results.next();
412		assertEquals("Incorrect ID Value", "B223", results.getString("ID"));
413		assertEquals("Incorrect NAME Value", "Binoy", results.getString("NAME"));
414
415		results.first();
416		assertEquals("Incorrect ID Value", "A123", results.getString("ID"));
417		assertEquals("Incorrect NAME Value", "Aman", results.getString("NAME"));
418
419		assertFalse(results.previous());
420		try
421		{
422		results.getString("ID");
423		fail("Should raise a java.sqlSQLException");
424		}
425		catch (SQLException e)
426		{
427		assertEquals("java.sql.SQLException: " + CsvResources.getString("noCurrentRow"), "" + e);
428		}
429		try
430		{
431		results.getString("NAME");
432		fail("Should raise a java.sqlSQLException");
433		}
434		catch (SQLException e)
435		{
436		assertEquals("java.sql.SQLException: " + CsvResources.getString("noCurrentRow"), "" + e);
437		}
438
439		results.next();
440		assertEquals("Incorrect ID Value", "A123", results.getString("ID"));
441		assertEquals("Incorrect NAME Value", "Aman", results.getString("NAME"));
442
443		results.next();
444		assertEquals("Incorrect ID Value", "B223", results.getString("ID"));
445		assertEquals("Incorrect NAME Value", "Binoy", results.getString("NAME"));
446
447		results.relative(2);
448		assertEquals("Incorrect ID Value", "D456", results.getString("ID"));
449		assertEquals("Incorrect NAME Value",
450		"Dilip \"meals\" Maurice\n ~In New LIne~ \nDone", results
451		.getString("NAME"));
452
453		results.relative(-3);
454		assertEquals("Incorrect ID Value", "A123", results.getString("ID"));
455		assertEquals("Incorrect NAME Value", "Aman", results.getString("NAME"));
456
457		results.relative(0);
458		assertEquals("Incorrect ID Value", "A123", results.getString("ID"));
459		assertEquals("Incorrect NAME Value", "Aman", results.getString("NAME"));
460
461		results.absolute(2);
462		assertEquals("Incorrect ID Value", "B223", results.getString("ID"));
463		assertEquals("Incorrect NAME Value", "Binoy", results.getString("NAME"));
464
465		results.absolute(-2);
466		assertEquals("Incorrect ID Value", "E589", results.getString("ID"));
467		assertEquals("Incorrect NAME Value", "\"Elephant\"", results
468		.getString("NAME"));
469
470		results.last();
471		assertEquals("Incorrect ID Value", "F634", results.getString("ID"));
472		assertEquals(
473		"Incorrect NAME Value",
474		"Fandu \"\"peg leg\"\", Jimmy & Samantha \n~In Another New LIne~ \n\"\"Sam\"\"",
475		results.getString("NAME"));
476
477		results.next();
478		assertNull(results.getString("ID"));
479		assertNull(results.getString("NAME"));
480
481		results.previous();
482		assertEquals("Incorrect ID Value", "F634", results.getString("ID"));
483		assertEquals(
484		"Incorrect NAME Value",
485		"Fandu \"\"peg leg\"\", Jimmy & Samantha \n~In Another New LIne~ \n\"\"Sam\"\"",
486		results.getString("NAME"));
487
488		results.relative(100);
489		assertNull(results.getString("ID"));
490		assertNull(results.getString("NAME"));
491
492		assertFalse(results.relative(-100));
493		try
494		{
495		results.getString("ID");
496		fail("Should raise a java.sqlSQLException");
497		}
498		catch (SQLException e)
499		{
500		assertEquals("java.sql.SQLException: " + CsvResources.getString("noCurrentRow"), "" + e);
501		}
502		try
503		{
504		results.getString("NAME");
505		fail("Should raise a java.sqlSQLException");
506		}
507		catch (SQLException e)
508		{
509		assertEquals("java.sql.SQLException: " + CsvResources.getString("noCurrentRow"), "" + e);
510		}
511
512		results.relative(2);
513		assertEquals("Incorrect ID Value", "B223", results.getString("ID"));
514		assertEquals("Incorrect NAME Value", "Binoy", results.getString("NAME"));
515
516		results.absolute(7);
517		assertNull(results.getString("ID"));
518		assertNull(results.getString("NAME"));
519
520		assertFalse(results.absolute(-10));
521		try
522		{
523		results.getString("ID");
524		fail("Should raise a java.sqlSQLException");
525		}
526		catch (SQLException e)
527		{
528		assertEquals("java.sql.SQLException: " + CsvResources.getString("noCurrentRow"), "" + e);
529		}
530		try
531		{
532		results.getString("NAME");
533		fail("Should raise a java.sqlSQLException");
534		}
535		catch (SQLException e)
536		{
537		assertEquals("java.sql.SQLException: " + CsvResources.getString("noCurrentRow"), "" + e);
538		}
539
540		results.absolute(2);
541		assertEquals("Incorrect ID Value", "B223", results.getString("ID"));
542		assertEquals("Incorrect NAME Value", "Binoy", results.getString("NAME"));
543
544		assertFalse(results.absolute(0));
545		try
546		{
547		results.getString("ID");
548		fail("Should raise a java.sqlSQLException");
549		}
550		catch (SQLException e)
551		{
552		assertEquals("java.sql.SQLException: " + CsvResources.getString("noCurrentRow"), "" + e);
553		}
554		try
555		{
556		results.getString("NAME");
557		fail("Should raise a java.sqlSQLException");
558		}
559		catch (SQLException e)
560		{
561		assertEquals("java.sql.SQLException: " + CsvResources.getString("noCurrentRow"), "" + e);
562		}
563
564		assertFalse(results.relative(0));
565		try
566		{
567		results.getString("ID");
568		fail("Should raise a java.sqlSQLException");
569		}
570		catch (SQLException e)
571		{
572		assertEquals("java.sql.SQLException: " + CsvResources.getString("noCurrentRow"), "" + e);
573		}
574		try
575		{
576		results.getString("NAME");
577		fail("Should raise a java.sqlSQLException");
578		}
579		catch (SQLException e)
580		{
581		assertEquals("java.sql.SQLException: " + CsvResources.getString("noCurrentRow"), "" + e);
582		}
583
584		// clean up
585		results.close();
586		stmt.close();
587		conn.close();
	387	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	388	+ filePath);
	389
	390	// create a Statement object to execute the query with
	391	Statement stmt = conn.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE,
	392	ResultSet.CONCUR_READ_ONLY);
	393
	394	// Select the ID and NAME columns from sample.csv
	395	ResultSet results = stmt.executeQuery("SELECT ID,NAME FROM sample2"))
	396	{
	397	// dump out the results
	398	results.next();
	399	assertEquals("Incorrect ID Value", "A123", results.getString("ID"));
	400	assertEquals("Incorrect NAME Value", "Aman", results.getString("NAME"));
	401
	402	results.next();
	403	assertEquals("Incorrect ID Value", "B223", results.getString("ID"));
	404	assertEquals("Incorrect NAME Value", "Binoy", results.getString("NAME"));
	405
	406	results.first();
	407	assertEquals("Incorrect ID Value", "A123", results.getString("ID"));
	408	assertEquals("Incorrect NAME Value", "Aman", results.getString("NAME"));
	409
	410	assertFalse(results.previous());
	411	try
	412	{
	413	results.getString("ID");
	414	fail("Should raise a java.sqlSQLException");
	415	}
	416	catch (SQLException e)
	417	{
	418	assertEquals("java.sql.SQLException: " + CsvResources.getString("noCurrentRow"), "" + e);
	419	}
	420	try
	421	{
	422	results.getString("NAME");
	423	fail("Should raise a java.sqlSQLException");
	424	}
	425	catch (SQLException e)
	426	{
	427	assertEquals("java.sql.SQLException: " + CsvResources.getString("noCurrentRow"), "" + e);
	428	}
	429
	430	results.next();
	431	assertEquals("Incorrect ID Value", "A123", results.getString("ID"));
	432	assertEquals("Incorrect NAME Value", "Aman", results.getString("NAME"));
	433
	434	results.next();
	435	assertEquals("Incorrect ID Value", "B223", results.getString("ID"));
	436	assertEquals("Incorrect NAME Value", "Binoy", results.getString("NAME"));
	437
	438	results.relative(2);
	439	assertEquals("Incorrect ID Value", "D456", results.getString("ID"));
	440	assertEquals("Incorrect NAME Value",
	441	"Dilip \"meals\" Maurice\n ~In New LIne~ \nDone", results
	442	.getString("NAME"));
	443
	444	results.relative(-3);
	445	assertEquals("Incorrect ID Value", "A123", results.getString("ID"));
	446	assertEquals("Incorrect NAME Value", "Aman", results.getString("NAME"));
	447
	448	results.relative(0);
	449	assertEquals("Incorrect ID Value", "A123", results.getString("ID"));
	450	assertEquals("Incorrect NAME Value", "Aman", results.getString("NAME"));
	451
	452	results.absolute(2);
	453	assertEquals("Incorrect ID Value", "B223", results.getString("ID"));
	454	assertEquals("Incorrect NAME Value", "Binoy", results.getString("NAME"));
	455
	456	results.absolute(-2);
	457	assertEquals("Incorrect ID Value", "E589", results.getString("ID"));
	458	assertEquals("Incorrect NAME Value", "\"Elephant\"", results
	459	.getString("NAME"));
	460
	461	results.last();
	462	assertEquals("Incorrect ID Value", "F634", results.getString("ID"));
	463	assertEquals(
	464	"Incorrect NAME Value",
	465	"Fandu \"\"peg leg\"\", Jimmy & Samantha \n~In Another New LIne~ \n\"\"Sam\"\"",
	466	results.getString("NAME"));
	467
	468	results.next();
	469	assertNull(results.getString("ID"));
	470	assertNull(results.getString("NAME"));
	471
	472	results.previous();
	473	assertEquals("Incorrect ID Value", "F634", results.getString("ID"));
	474	assertEquals(
	475	"Incorrect NAME Value",
	476	"Fandu \"\"peg leg\"\", Jimmy & Samantha \n~In Another New LIne~ \n\"\"Sam\"\"",
	477	results.getString("NAME"));
	478
	479	results.relative(100);
	480	assertNull(results.getString("ID"));
	481	assertNull(results.getString("NAME"));
	482
	483	assertFalse(results.relative(-100));
	484	try
	485	{
	486	results.getString("ID");
	487	fail("Should raise a java.sqlSQLException");
	488	}
	489	catch (SQLException e)
	490	{
	491	assertEquals("java.sql.SQLException: " + CsvResources.getString("noCurrentRow"), "" + e);
	492	}
	493	try
	494	{
	495	results.getString("NAME");
	496	fail("Should raise a java.sqlSQLException");
	497	}
	498	catch (SQLException e)
	499	{
	500	assertEquals("java.sql.SQLException: " + CsvResources.getString("noCurrentRow"), "" + e);
	501	}
	502
	503	results.relative(2);
	504	assertEquals("Incorrect ID Value", "B223", results.getString("ID"));
	505	assertEquals("Incorrect NAME Value", "Binoy", results.getString("NAME"));
	506
	507	results.absolute(7);
	508	assertNull(results.getString("ID"));
	509	assertNull(results.getString("NAME"));
	510
	511	assertFalse(results.absolute(-10));
	512	try
	513	{
	514	results.getString("ID");
	515	fail("Should raise a java.sqlSQLException");
	516	}
	517	catch (SQLException e)
	518	{
	519	assertEquals("java.sql.SQLException: " + CsvResources.getString("noCurrentRow"), "" + e);
	520	}
	521	try
	522	{
	523	results.getString("NAME");
	524	fail("Should raise a java.sqlSQLException");
	525	}
	526	catch (SQLException e)
	527	{
	528	assertEquals("java.sql.SQLException: " + CsvResources.getString("noCurrentRow"), "" + e);
	529	}
	530
	531	results.absolute(2);
	532	assertEquals("Incorrect ID Value", "B223", results.getString("ID"));
	533	assertEquals("Incorrect NAME Value", "Binoy", results.getString("NAME"));
	534
	535	assertFalse(results.absolute(0));
	536	try
	537	{
	538	results.getString("ID");
	539	fail("Should raise a java.sqlSQLException");
	540	}
	541	catch (SQLException e)
	542	{
	543	assertEquals("java.sql.SQLException: " + CsvResources.getString("noCurrentRow"), "" + e);
	544	}
	545	try
	546	{
	547	results.getString("NAME");
	548	fail("Should raise a java.sqlSQLException");
	549	}
	550	catch (SQLException e)
	551	{
	552	assertEquals("java.sql.SQLException: " + CsvResources.getString("noCurrentRow"), "" + e);
	553	}
	554
	555	assertFalse(results.relative(0));
	556	try
	557	{
	558	results.getString("ID");
	559	fail("Should raise a java.sqlSQLException");
	560	}
	561	catch (SQLException e)
	562	{
	563	assertEquals("java.sql.SQLException: " + CsvResources.getString("noCurrentRow"), "" + e);
	564	}
	565	try
	566	{
	567	results.getString("NAME");
	568	fail("Should raise a java.sqlSQLException");
	569	}
	570	catch (SQLException e)
	571	{
	572	assertEquals("java.sql.SQLException: " + CsvResources.getString("noCurrentRow"), "" + e);
	573	}
	574	}
588	575	}
589	576
590	577	/**
591	578	* This checks for the scenario when due to where clause no rows are
592	579	* returned.
593		*
	580	*
594	581	* @throws SQLException
595	582	*/
596	583	@Test
597	584	public void testWhereNoResults() throws SQLException
598	585	{
599		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
600		+ filePath);
601		// create a Statement object to execute the query with
602		Statement stmt = conn.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE,
603		ResultSet.CONCUR_READ_ONLY);
604
605		ResultSet results = stmt
606		.executeQuery("SELECT ID,Name FROM sample4 WHERE ID='05'");
607		assertFalse("There are some junk records found", results.next());
608		assertFalse(results.last());
609		try
610		{
611		results.getString("ID");
612		fail("Should raise a java.sqlSQLException");
613		}
614		catch (SQLException e)
615		{
616		assertEquals("java.sql.SQLException: " + CsvResources.getString("noCurrentRow"), "" + e);
617		}
618		try
619		{
620		results.getString("NAME");
621		fail("Should raise a java.sqlSQLException");
622		}
623		catch (SQLException e)
624		{
625		assertEquals("java.sql.SQLException: " + CsvResources.getString("noCurrentRow"), "" + e);
626		}
627		assertTrue("Is not last", results.isLast());
628		assertFalse(results.absolute(0));
629		try
630		{
631		results.getString("ID");
632		fail("Should raise a java.sqlSQLException");
633		}
634		catch (SQLException e)
635		{
636		assertEquals("java.sql.SQLException: " + CsvResources.getString("noCurrentRow"), "" + e);
637		}
638		try
639		{
640		results.getString("NAME");
641		fail("Should raise a java.sqlSQLException");
642		}
643		catch (SQLException e)
644		{
645		assertEquals("java.sql.SQLException: " + CsvResources.getString("noCurrentRow"), "" + e);
646		}
647		assertTrue("Is not last", results.isLast());
648		assertFalse(results.absolute(0));
649		assertTrue("Is not before first", results.isBeforeFirst());
650		results.previous();
651		assertTrue("Is not before first", results.isBeforeFirst());
652		assertTrue("Is not last", results.isLast());
653		// Following throws exception
654		// assertTrue("Is not before first", results.isAfterLast());
655
	586	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	587	+ filePath);
	588	// create a Statement object to execute the query with
	589	Statement stmt = conn.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE,
	590	ResultSet.CONCUR_READ_ONLY);
	591
	592	ResultSet results = stmt
	593	.executeQuery("SELECT ID,Name FROM sample4 WHERE ID='05'"))
	594	{
	595	assertFalse("There are some junk records found", results.next());
	596	assertFalse(results.last());
	597	try
	598	{
	599	results.getString("ID");
	600	fail("Should raise a java.sqlSQLException");
	601	}
	602	catch (SQLException e)
	603	{
	604	assertEquals("java.sql.SQLException: " + CsvResources.getString("noCurrentRow"), "" + e);
	605	}
	606	try
	607	{
	608	results.getString("NAME");
	609	fail("Should raise a java.sqlSQLException");
	610	}
	611	catch (SQLException e)
	612	{
	613	assertEquals("java.sql.SQLException: " + CsvResources.getString("noCurrentRow"), "" + e);
	614	}
	615	assertTrue("Is not last", results.isLast());
	616	assertFalse(results.absolute(0));
	617	try
	618	{
	619	results.getString("ID");
	620	fail("Should raise a java.sqlSQLException");
	621	}
	622	catch (SQLException e)
	623	{
	624	assertEquals("java.sql.SQLException: " + CsvResources.getString("noCurrentRow"), "" + e);
	625	}
	626	try
	627	{
	628	results.getString("NAME");
	629	fail("Should raise a java.sqlSQLException");
	630	}
	631	catch (SQLException e)
	632	{
	633	assertEquals("java.sql.SQLException: " + CsvResources.getString("noCurrentRow"), "" + e);
	634	}
	635	assertTrue("Is not last", results.isLast());
	636	assertFalse(results.absolute(0));
	637	assertTrue("Is not before first", results.isBeforeFirst());
	638	results.previous();
	639	assertTrue("Is not before first", results.isBeforeFirst());
	640	assertTrue("Is not last", results.isLast());
	641	// Following throws exception
	642	// assertTrue("Is not before first", results.isAfterLast());
	643	}
656	644	}
657	645
658	646	/**
659	647	* This checks for the scenario when we have single record
660		*
	648	*
661	649	* @throws SQLException
662	650	*/
663	651	@Test
664	652	public void testWhereSingleRecord() throws SQLException
665	653	{
666		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
667		+ filePath);
668		// create a Statement object to execute the query with
669		Statement stmt = conn.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE,
670		ResultSet.CONCUR_READ_ONLY);
671
672		ResultSet results = stmt
673		.executeQuery("SELECT ID,Name FROM singlerecord");
674		assertTrue(results.last());
675		assertEquals("Invalid Id", "A123", results.getString("ID"));
676		assertEquals("Invalid Name", "Jonathan Ackerman", results
677		.getString("NAME"));
678		results.absolute(1);
679		assertEquals("Invalid Id", "A123", results.getString("ID"));
680		assertEquals("Invalid Name", "Jonathan Ackerman", results
681		.getString("NAME"));
682		assertTrue("Is not last", results.isLast());
683		assertTrue("Is not first", results.isFirst());
684		results.absolute(0);
685		assertTrue("Is not before first", results.isBeforeFirst());
686		results.previous();
687		assertTrue("Is not before first", results.isBeforeFirst());
688		assertTrue(results.next());
689		assertEquals("Invalid Id", "A123", results.getString("ID"));
690		assertEquals("Invalid Name", "Jonathan Ackerman", results
691		.getString("NAME"));
692		results.relative(1);
693		assertTrue("Is not after last", results.isAfterLast());
694		results.previous();
695		assertEquals("Invalid Id", "A123", results.getString("ID"));
696		assertEquals("Invalid Name", "Jonathan Ackerman", results
697		.getString("NAME"));
	654	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	655	+ filePath);
	656	// create a Statement object to execute the query with
	657	Statement stmt = conn.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE,
	658	ResultSet.CONCUR_READ_ONLY);
	659
	660	ResultSet results = stmt
	661	.executeQuery("SELECT ID,Name FROM singlerecord"))
	662	{
	663	assertTrue(results.last());
	664	assertEquals("Invalid Id", "A123", results.getString("ID"));
	665	assertEquals("Invalid Name", "Jonathan Ackerman", results
	666	.getString("NAME"));
	667	results.absolute(1);
	668	assertEquals("Invalid Id", "A123", results.getString("ID"));
	669	assertEquals("Invalid Name", "Jonathan Ackerman", results
	670	.getString("NAME"));
	671	assertTrue("Is not last", results.isLast());
	672	assertTrue("Is not first", results.isFirst());
	673	results.absolute(0);
	674	assertTrue("Is not before first", results.isBeforeFirst());
	675	results.previous();
	676	assertTrue("Is not before first", results.isBeforeFirst());
	677	assertTrue(results.next());
	678	assertEquals("Invalid Id", "A123", results.getString("ID"));
	679	assertEquals("Invalid Name", "Jonathan Ackerman", results
	680	.getString("NAME"));
	681	results.relative(1);
	682	assertTrue("Is not after last", results.isAfterLast());
	683	results.previous();
	684	assertEquals("Invalid Id", "A123", results.getString("ID"));
	685	assertEquals("Invalid Name", "Jonathan Ackerman", results
	686	.getString("NAME"));
	687	}
698	688	}
699	689
700	690	/**
701	691	* This tests for the scenario with where clause.
702		*
	692	*
703	693	* @throws SQLException
704	694	*/
705	695	@Test
706	696	public void testWhereMultipleResult() throws SQLException
707	697	{
708		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
709		+ filePath);
710
711		Statement stmt = conn.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE,
712		ResultSet.CONCUR_READ_ONLY);
713
714		ResultSet results = stmt
715		.executeQuery("SELECT ID, Name, Job FROM sample4 WHERE Job = 'Project Manager'");
716		assertTrue(results.next());
717		assertEquals("The ID is wrong", "01", results.getString("ID"));
718		assertTrue(results.next());
719		assertEquals("The ID is wrong", "02", results.getString("ID"));
720		assertTrue(results.next());
721		assertEquals("The ID is wrong", "04", results.getString("ID"));
722		assertTrue(results.first());
723		assertEquals("The ID is wrong when using first", "01", results
724		.getString("ID"));
725
726		assertTrue(results.absolute(3));
727		assertEquals("The ID is wrong", "04", results.getString("ID"));
728
729		assertTrue(results.last());
730		assertEquals("The ID is wrong", "04", results.getString("ID"));
731		assertFalse("It has records after last", results.next());
732		assertTrue("Is not after Last", results.isAfterLast());
733		assertTrue(results.previous());
734		assertTrue(results.previous());
735		assertEquals("The ID is wrong", "02", results.getString("ID"));
736		assertTrue(results.relative(0));
737		assertEquals("The ID is wrong", "02", results.getString("ID"));
738		assertTrue(results.relative(1));
739		assertEquals("The ID is wrong", "04", results.getString("ID"));
740		assertTrue("Is not last", results.isLast());
741		assertTrue(results.relative(-2));
742		assertEquals("The ID is wrong", "01", results.getString("ID"));
743		assertTrue("Is not first", results.isFirst());
744		results.previous();
745		assertTrue("Is not before first", results.isBeforeFirst());
746
	698	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	699	+ filePath);
	700
	701	Statement stmt = conn.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE,
	702	ResultSet.CONCUR_READ_ONLY);
	703
	704	ResultSet results = stmt
	705	.executeQuery("SELECT ID, Name, Job FROM sample4 WHERE Job = 'Project Manager'"))
	706	{
	707	assertTrue(results.next());
	708	assertEquals("The ID is wrong", "01", results.getString("ID"));
	709	assertTrue(results.next());
	710	assertEquals("The ID is wrong", "02", results.getString("ID"));
	711	assertTrue(results.next());
	712	assertEquals("The ID is wrong", "04", results.getString("ID"));
	713	assertTrue(results.first());
	714	assertEquals("The ID is wrong when using first", "01", results
	715	.getString("ID"));
	716
	717	assertTrue(results.absolute(3));
	718	assertEquals("The ID is wrong", "04", results.getString("ID"));
	719
	720	assertTrue(results.last());
	721	assertEquals("The ID is wrong", "04", results.getString("ID"));
	722	assertFalse("It has records after last", results.next());
	723	assertTrue("Is not after Last", results.isAfterLast());
	724	assertTrue(results.previous());
	725	assertTrue(results.previous());
	726	assertEquals("The ID is wrong", "02", results.getString("ID"));
	727	assertTrue(results.relative(0));
	728	assertEquals("The ID is wrong", "02", results.getString("ID"));
	729	assertTrue(results.relative(1));
	730	assertEquals("The ID is wrong", "04", results.getString("ID"));
	731	assertTrue("Is not last", results.isLast());
	732	assertTrue(results.relative(-2));
	733	assertEquals("The ID is wrong", "01", results.getString("ID"));
	734	assertTrue("Is not first", results.isFirst());
	735	results.previous();
	736	assertTrue("Is not before first", results.isBeforeFirst());
	737	}
747	738	}
748	739
749	740	@Test
750	741	public void testMaxRows() throws SQLException
751	742	{
752		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
753		+ filePath);
754
755		Statement stmt = conn.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_READ_ONLY);
756		stmt.setMaxRows(4);
757		assertEquals("getMaxRows() incorrect", 4, stmt.getMaxRows());
758
759		ResultSet results = stmt.executeQuery("SELECT * FROM sample5");
760
761		assertTrue("Moving to last record failed", results.last());
762		assertEquals("Last record wrong", 4, results.getRow());
763		assertEquals("The ID is wrong", "03", results.getString("ID"));
764		assertTrue("Moving to first record failed", results.first());
765		assertEquals("The ID is wrong", "41", results.getString("ID"));
766		assertTrue("Reading row 2 failed", results.next());
767		assertTrue("Reading row 3 failed", results.next());
768		assertTrue("Reading row 4 failed", results.next());
769		assertFalse("Stopping after row 4 failed", results.next());
	743	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	744	+ filePath);
	745
	746	Statement stmt = conn.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_READ_ONLY))
	747	{
	748	stmt.setMaxRows(4);
	749	assertEquals("getMaxRows() incorrect", 4, stmt.getMaxRows());
	750
	751	try (ResultSet results = stmt.executeQuery("SELECT * FROM sample5"))
	752	{
	753	assertTrue("Moving to last record failed", results.last());
	754	assertEquals("Last record wrong", 4, results.getRow());
	755	assertEquals("The ID is wrong", "03", results.getString("ID"));
	756	assertTrue("Moving to first record failed", results.first());
	757	assertEquals("The ID is wrong", "41", results.getString("ID"));
	758	assertTrue("Reading row 2 failed", results.next());
	759	assertTrue("Reading row 3 failed", results.next());
	760	assertTrue("Reading row 4 failed", results.next());
	761	assertFalse("Stopping after row 4 failed", results.next());
	762	}
	763	}
770	764	}
771	765
772	766	@Test
773	767	public void testResultSetFirstClosed() throws SQLException
774	768	{
775		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
776		+ filePath);
777
778		Statement stmt = conn.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_READ_ONLY);
779		ResultSet results = stmt.executeQuery("SELECT * FROM sample");
780		results.next();
781		results.next();
782		results.close();
783		try
784		{
785		results.first();
786		fail("Closed result set should throw SQLException");
787		}
788		catch (SQLException e)
789		{
790		assertEquals("java.sql.SQLException: " + CsvResources.getString("closedResultSet"), "" + e);
791		}
792
793		// clean up
794		stmt.close();
795		conn.close();
	769	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	770	+ filePath);
	771
	772	Statement stmt = conn.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_READ_ONLY);
	773	ResultSet results = stmt.executeQuery("SELECT * FROM sample"))
	774	{
	775	results.next();
	776	results.next();
	777	results.close();
	778	try
	779	{
	780	results.first();
	781	fail("Closed result set should throw SQLException");
	782	}
	783	catch (SQLException e)
	784	{
	785	assertEquals("java.sql.SQLException: " + CsvResources.getString("closedResultSet"), "" + e);
	786	}
	787	}
796	788	}
797	789
798	790	@Test
799	791	public void testResultSetLastClosed() throws SQLException
800	792	{
801		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
802		+ filePath);
803
804		Statement stmt = conn.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_READ_ONLY);
805		ResultSet results = stmt.executeQuery("SELECT * FROM sample");
806		results.next();
807		results.next();
808		results.close();
809		try
810		{
811		results.last();
812		fail("Closed result set should throw SQLException");
813		}
814		catch (SQLException e)
815		{
816		assertEquals("java.sql.SQLException: " + CsvResources.getString("closedResultSet"), "" + e);
817		}
818
819		// clean up
820		stmt.close();
821		conn.close();
	793	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	794	+ filePath);
	795
	796	Statement stmt = conn.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_READ_ONLY);
	797	ResultSet results = stmt.executeQuery("SELECT * FROM sample"))
	798	{
	799	results.next();
	800	results.next();
	801	results.close();
	802	try
	803	{
	804	results.last();
	805	fail("Closed result set should throw SQLException");
	806	}
	807	catch (SQLException e)
	808	{
	809	assertEquals("java.sql.SQLException: " + CsvResources.getString("closedResultSet"), "" + e);
	810	}
	811	}
822	812	}
823	813
824	814	@Test
825	815	public void testResultSetPreviousClosed() throws SQLException
826	816	{
827		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
828		+ filePath);
829
830		Statement stmt = conn.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_READ_ONLY);
831		ResultSet results = stmt.executeQuery("SELECT * FROM sample");
832		results.next();
833		results.next();
834		results.close();
835		try
836		{
837		results.previous();
838		fail("Closed result set should throw SQLException");
839		}
840		catch (SQLException e)
841		{
842		assertEquals("java.sql.SQLException: " + CsvResources.getString("closedResultSet"), "" + e);
843		}
844
845		// clean up
846		stmt.close();
847		conn.close();
	817	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	818	+ filePath);
	819
	820	Statement stmt = conn.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_READ_ONLY);
	821	ResultSet results = stmt.executeQuery("SELECT * FROM sample"))
	822	{
	823	results.next();
	824	results.next();
	825	results.close();
	826	try
	827	{
	828	results.previous();
	829	fail("Closed result set should throw SQLException");
	830	}
	831	catch (SQLException e)
	832	{
	833	assertEquals("java.sql.SQLException: " + CsvResources.getString("closedResultSet"), "" + e);
	834	}
	835	}
848	836	}
849	837
850	838	@Test
851	839	public void testResultSetAbsoluteClosed() throws SQLException
852	840	{
853		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
854		+ filePath);
855
856		Statement stmt = conn.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_READ_ONLY);
857		ResultSet results = stmt.executeQuery("SELECT * FROM sample");
858		results.next();
859		results.next();
860		results.close();
861		try
862		{
863		results.absolute(2);
864		fail("Closed result set should throw SQLException");
865		}
866		catch (SQLException e)
867		{
868		assertEquals("java.sql.SQLException: " + CsvResources.getString("closedResultSet"), "" + e);
869		}
870
871		// clean up
872		stmt.close();
873		conn.close();
	841	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	842	+ filePath);
	843
	844	Statement stmt = conn.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_READ_ONLY);
	845	ResultSet results = stmt.executeQuery("SELECT * FROM sample"))
	846	{
	847	results.next();
	848	results.next();
	849	results.close();
	850	try
	851	{
	852	results.absolute(2);
	853	fail("Closed result set should throw SQLException");
	854	}
	855	catch (SQLException e)
	856	{
	857	assertEquals("java.sql.SQLException: " + CsvResources.getString("closedResultSet"), "" + e);
	858	}
	859	}
874	860	}
875	861
876	862	@Test
877	863	public void testResultSetRelativeClosed() throws SQLException
878	864	{
879		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
880		+ filePath);
881
882		Statement stmt = conn.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_READ_ONLY);
883		ResultSet results = stmt.executeQuery("SELECT * FROM sample");
884		results.next();
885		results.next();
886		results.close();
887		try
888		{
889		results.relative(-1);
890		fail("Closed result set should throw SQLException");
891		}
892		catch (SQLException e)
893		{
894		assertEquals("java.sql.SQLException: " + CsvResources.getString("closedResultSet"), "" + e);
895		}
896
897		// clean up
898		stmt.close();
899		conn.close();
	865	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	866	+ filePath);
	867
	868	Statement stmt = conn.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_READ_ONLY);
	869	ResultSet results = stmt.executeQuery("SELECT * FROM sample"))
	870	{
	871	results.next();
	872	results.next();
	873	results.close();
	874	try
	875	{
	876	results.relative(-1);
	877	fail("Closed result set should throw SQLException");
	878	}
	879	catch (SQLException e)
	880	{
	881	assertEquals("java.sql.SQLException: " + CsvResources.getString("closedResultSet"), "" + e);
	882	}
	883	}
900	884	}
901	885
902	886	@Test
903	887	public void testResultSetAfterLastClosed() throws SQLException
904	888	{
905		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
906		+ filePath);
907
908		Statement stmt = conn.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_READ_ONLY);
909		ResultSet results = stmt.executeQuery("SELECT * FROM sample");
910		results.next();
911		results.next();
912		results.close();
913		try
914		{
915		results.afterLast();
916		fail("Closed result set should throw SQLException");
917		}
918		catch (SQLException e)
919		{
920		assertEquals("java.sql.SQLException: " + CsvResources.getString("closedResultSet"), "" + e);
921		}
922
923		// clean up
924		stmt.close();
925		conn.close();
	889	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	890	+ filePath);
	891
	892	Statement stmt = conn.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_READ_ONLY);
	893	ResultSet results = stmt.executeQuery("SELECT * FROM sample"))
	894	{
	895	results.next();
	896	results.next();
	897	results.close();
	898	try
	899	{
	900	results.afterLast();
	901	fail("Closed result set should throw SQLException");
	902	}
	903	catch (SQLException e)
	904	{
	905	assertEquals("java.sql.SQLException: " + CsvResources.getString("closedResultSet"), "" + e);
	906	}
	907	}
926	908	}
927	909
928	910	@Test
929	911	public void testResultSetBeforeFirstClosed() throws SQLException
930	912	{
931		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
932		+ filePath);
933
934		Statement stmt = conn.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_READ_ONLY);
935		ResultSet results = stmt.executeQuery("SELECT * FROM sample");
936		results.next();
937		results.next();
938		results.close();
939		try
940		{
941		results.beforeFirst();
942		fail("Closed result set should throw SQLException");
943		}
944		catch (SQLException e)
945		{
946		assertEquals("java.sql.SQLException: " + CsvResources.getString("closedResultSet"), "" + e);
947		}
948
949		// clean up
950		stmt.close();
951		conn.close();
	913	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	914	+ filePath);
	915
	916	Statement stmt = conn.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_READ_ONLY);
	917	ResultSet results = stmt.executeQuery("SELECT * FROM sample"))
	918	{
	919	results.next();
	920	results.next();
	921	results.close();
	922	try
	923	{
	924	results.beforeFirst();
	925	fail("Closed result set should throw SQLException");
	926	}
	927	catch (SQLException e)
	928	{
	929	assertEquals("java.sql.SQLException: " + CsvResources.getString("closedResultSet"), "" + e);
	930	}
	931	}
952	932	}
953	933
954	934	@Test
955	935	public void testResultSetIsAfterLastClosed() throws SQLException
956	936	{
957		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
958		+ filePath);
959
960		Statement stmt = conn.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_READ_ONLY);
961		ResultSet results = stmt.executeQuery("SELECT * FROM sample");
962		results.next();
963		results.next();
964		results.close();
965		try
966		{
967		results.isAfterLast();
968		fail("Closed result set should throw SQLException");
969		}
970		catch (SQLException e)
971		{
972		assertEquals("java.sql.SQLException: " + CsvResources.getString("closedResultSet"), "" + e);
973		}
974
975		// clean up
976		stmt.close();
977		conn.close();
	937	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	938	+ filePath);
	939
	940	Statement stmt = conn.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_READ_ONLY);
	941	ResultSet results = stmt.executeQuery("SELECT * FROM sample"))
	942	{
	943	results.next();
	944	results.next();
	945	results.close();
	946	try
	947	{
	948	results.isAfterLast();
	949	fail("Closed result set should throw SQLException");
	950	}
	951	catch (SQLException e)
	952	{
	953	assertEquals("java.sql.SQLException: " + CsvResources.getString("closedResultSet"), "" + e);
	954	}
	955	}
978	956	}
979	957
980	958	@Test
981	959	public void testResultSetIsBeforeFirstClosed() throws SQLException
982	960	{
983		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
984		+ filePath);
985
986		Statement stmt = conn.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_READ_ONLY);
987		ResultSet results = stmt.executeQuery("SELECT * FROM sample");
988		results.next();
989		results.next();
990		results.close();
991		try
992		{
993		results.isBeforeFirst();
994		fail("Closed result set should throw SQLException");
995		}
996		catch (SQLException e)
997		{
998		assertEquals("java.sql.SQLException: " + CsvResources.getString("closedResultSet"), "" + e);
999		}
1000
1001		// clean up
1002		stmt.close();
1003		conn.close();
	961	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	962	+ filePath);
	963
	964	Statement stmt = conn.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_READ_ONLY);
	965	ResultSet results = stmt.executeQuery("SELECT * FROM sample"))
	966	{
	967	results.next();
	968	results.next();
	969	results.close();
	970	try
	971	{
	972	results.isBeforeFirst();
	973	fail("Closed result set should throw SQLException");
	974	}
	975	catch (SQLException e)
	976	{
	977	assertEquals("java.sql.SQLException: " + CsvResources.getString("closedResultSet"), "" + e);
	978	}
	979	}
1004	980	}
1005	981
1006	982	@Test
1007	983	public void testResultSetIsFirstClosed() throws SQLException
1008	984	{
1009		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
1010		+ filePath);
1011
1012		Statement stmt = conn.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_READ_ONLY);
1013		ResultSet results = stmt.executeQuery("SELECT * FROM sample");
1014		results.next();
1015		results.next();
1016		results.close();
1017		try
1018		{
1019		results.isFirst();
1020		fail("Closed result set should throw SQLException");
1021		}
1022		catch (SQLException e)
1023		{
1024		assertEquals("java.sql.SQLException: " + CsvResources.getString("closedResultSet"), "" + e);
1025		}
1026
1027		// clean up
1028		stmt.close();
1029		conn.close();
	985	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	986	+ filePath);
	987
	988	Statement stmt = conn.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_READ_ONLY);
	989	ResultSet results = stmt.executeQuery("SELECT * FROM sample"))
	990	{
	991	results.next();
	992	results.next();
	993	results.close();
	994	try
	995	{
	996	results.isFirst();
	997	fail("Closed result set should throw SQLException");
	998	}
	999	catch (SQLException e)
	1000	{
	1001	assertEquals("java.sql.SQLException: " + CsvResources.getString("closedResultSet"), "" + e);
	1002	}
	1003	}
1030	1004	}
1031	1005
1032	1006	@Test
1033	1007	public void testResultSetIsLastClosed() throws SQLException
1034	1008	{
1035		Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
1036		+ filePath);
1037
1038		Statement stmt = conn.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_READ_ONLY);
1039		ResultSet results = stmt.executeQuery("SELECT * FROM sample");
1040		results.next();
1041		results.next();
1042		results.close();
1043		try
1044		{
1045		results.isLast();
1046		fail("Closed result set should throw SQLException");
1047		}
1048		catch (SQLException e)
1049		{
1050		assertEquals("java.sql.SQLException: " + CsvResources.getString("closedResultSet"), "" + e);
1051		}
1052
1053		// clean up
1054		stmt.close();
1055		conn.close();
	1009	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:"
	1010	+ filePath);
	1011
	1012	Statement stmt = conn.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE, ResultSet.CONCUR_READ_ONLY);
	1013	ResultSet results = stmt.executeQuery("SELECT * FROM sample"))
	1014	{
	1015	results.next();
	1016	results.next();
	1017	results.close();
	1018	try
	1019	{
	1020	results.isLast();
	1021	fail("Closed result set should throw SQLException");
	1022	}
	1023	catch (SQLException e)
	1024	{
	1025	assertEquals("java.sql.SQLException: " + CsvResources.getString("closedResultSet"), "" + e);
	1026	}
	1027	}
1056	1028	}
1057	1029	}

+72

-78

src/test/java/org/relique/jdbc/csv/TestSqlParser.java less more

31	31	import java.util.Map;
32	32
33	33	import org.junit.Test;
34		import org.relique.jdbc.csv.Expression;
35		import org.relique.jdbc.csv.ExpressionParser;
36		import org.relique.jdbc.csv.MultipleSqlParser;
37		import org.relique.jdbc.csv.ParseException;
38		import org.relique.jdbc.csv.SqlParser;
39		import org.relique.jdbc.csv.StringConverter;
40	34
41	35	/**
42	36	* This class is used to test the SqlParser class.

353	347
354	348	parser.parse("SELECT * FROM test WHERE c=1");
355	349	env.clear();
356		env.put("C", new Integer("1"));
	350	env.put("C", Integer.valueOf("1"));
357	351	assertEquals(Boolean.TRUE, parser.getWhereClause().isTrue(env));
358	352
359	353	parser.parse("SELECT * FROM test WHERE c='1'");

363	357
364	358	parser.parse("SELECT * FROM test WHERE c=1.0");
365	359	env.clear();
366		env.put("C", new Double("1.0"));
	360	env.put("C", Double.valueOf("1.0"));
367	361	assertEquals(Boolean.TRUE, parser.getWhereClause().isTrue(env));
368	362
369	363	parser.parse("SELECT * FROM test WHERE (A='20' OR B='AA') AND c=1");

372	366	env.clear();
373	367	env.put("A", new String("20"));
374	368	env.put("B", new String("AA"));
375		env.put("C", new Integer("1"));
	369	env.put("C", Integer.valueOf("1"));
376	370	assertEquals(Boolean.TRUE, whereClause.isTrue(env));
377		env.put("A", new Double("20"));
	371	env.put("A", Double.valueOf("20"));
378	372	assertEquals(Boolean.TRUE, whereClause.isTrue(env));
379	373	env.put("B", new String(""));
380	374	assertEquals(Boolean.FALSE, whereClause.isTrue(env));
381	375	env.put("A", new String("20"));
382	376	assertEquals(Boolean.TRUE, whereClause.isTrue(env));
383		env.put("C", new Integer("3"));
	377	env.put("C", Integer.valueOf("3"));
384	378	assertEquals(Boolean.FALSE, whereClause.isTrue(env));
385	379	}
386	380

392	386	{
393	387	SqlParser parser = new SqlParser();
394	388	Map<String, Object> env = new HashMap<String, Object>();
395		env.put("C", new Integer("12"));
	389	env.put("C", Integer.valueOf("12"));
396	390
397	391	parser.parse("SELECT * FROM test WHERE c=1");
398	392	assertEquals(Boolean.FALSE, parser.getWhereClause().isTrue(env));

461	455
462	456	parser.parse("SELECT * FROM test WHERE c=1.0");
463	457	env.clear();
464		env.put("C", new Integer("1"));
465		assertEquals(Boolean.TRUE, parser.getWhereClause().isTrue(env));
466		env.put("C", new Double("1"));
467		assertEquals(Boolean.TRUE, parser.getWhereClause().isTrue(env));
468		env.put("C", new Float("1"));
	458	env.put("C", Integer.valueOf("1"));
	459	assertEquals(Boolean.TRUE, parser.getWhereClause().isTrue(env));
	460	env.put("C", Double.valueOf("1"));
	461	assertEquals(Boolean.TRUE, parser.getWhereClause().isTrue(env));
	462	env.put("C", Float.valueOf("1"));
469	463	assertEquals(Boolean.TRUE, parser.getWhereClause().isTrue(env));
470	464	}
471	465

477	471
478	472	parser.parse("SELECT * FROM test WHERE c=-1.0");
479	473	env.clear();
480		env.put("C", new Integer("-1"));
481		assertEquals(Boolean.TRUE, parser.getWhereClause().isTrue(env));
482		env.put("C", new Double("-1"));
483		assertEquals(Boolean.TRUE, parser.getWhereClause().isTrue(env));
484		env.put("C", new Float("-1"));
	474	env.put("C", Integer.valueOf("-1"));
	475	assertEquals(Boolean.TRUE, parser.getWhereClause().isTrue(env));
	476	env.put("C", Double.valueOf("-1"));
	477	assertEquals(Boolean.TRUE, parser.getWhereClause().isTrue(env));
	478	env.put("C", Float.valueOf("-1"));
485	479	assertEquals(Boolean.TRUE, parser.getWhereClause().isTrue(env));
486	480	}
487	481

578	572	cs = new ExpressionParser(new StringReader("A+b AS result"));
579	573	cs.parseQueryEnvEntry();
580	574	Map<String, Object> env = new HashMap<String, Object>();
581		env.put("A", new Integer(1));
582
583		env.put("B", new Integer(1));
584		assertEquals((Object)(new Integer("2")), cs.eval(env));
585		env.put("A", new Double(1));
586		assertEquals((Object)(new Double("2")), cs.eval(env));
	575	env.put("A", Integer.valueOf(1));
	576
	577	env.put("B", Integer.valueOf(1));
	578	assertEquals((Object)(Integer.valueOf("2")), cs.eval(env));
	579	env.put("A", Double.valueOf(1));
	580	assertEquals((Object)(Double.valueOf("2")), cs.eval(env));
587	581	env.put("A", new String("1"));
588	582	// string concatenation because one of the arguments is a string
589	583	assertEquals("11", ""+cs.eval(env));

600	594	env.put("A", "Hello");
601	595	env.put("B", "World");
602	596	assertEquals("HelloWorld", cs.eval(env));
603		env.put("B", new Integer(100));
	597	env.put("B", Integer.valueOf(100));
604	598	assertEquals("Hello100", cs.eval(env));
605	599	}
606	600

614	608
615	609	Map<String, Object> env = new HashMap<String, Object>();
616	610
617		env.put("A", new Integer(4));
618		env.put("B", new Integer(3));
619		assertEquals((Object)(new Integer("1")), cs.eval(env));
620
621		env.put("A", new Integer(-3));
622		env.put("B", new Integer(2));
623		assertEquals((Object)(new Integer("-1")), cs.eval(env));
624
625		env.put("A", new Integer(4));
626		env.put("B", new Integer(0));
	611	env.put("A", Integer.valueOf(4));
	612	env.put("B", Integer.valueOf(3));
	613	assertEquals((Object)(Integer.valueOf("1")), cs.eval(env));
	614
	615	env.put("A", Integer.valueOf(-3));
	616	env.put("B", Integer.valueOf(2));
	617	assertEquals((Object)(Integer.valueOf("-1")), cs.eval(env));
	618
	619	env.put("A", Integer.valueOf(4));
	620	env.put("B", Integer.valueOf(0));
627	621	try
628	622	{
629	623	cs.eval(env);

634	628
635	629	}
636	630
637		env.put("A", new Double(5));
638		env.put("B", new Double(3));
639		assertEquals((Object)(new Double("2")), cs.eval(env));
640
641		env.put("A", new Double(8.8));
642		env.put("B", new Double(3.3));
643		assertEquals((Object)(new Double("2.2")), cs.eval(env));
644
645		env.put("A", new Double(-5));
646		env.put("B", new Double(3));
647		assertEquals((Object)(new Double("-2")), cs.eval(env));
	631	env.put("A", Double.valueOf(5));
	632	env.put("B", Double.valueOf(3));
	633	assertEquals((Object)(Double.valueOf("2")), cs.eval(env));
	634
	635	env.put("A", Double.valueOf(8.8));
	636	env.put("B", Double.valueOf(3.3));
	637	assertEquals((Object)(Double.valueOf("2.2")), cs.eval(env));
	638
	639	env.put("A", Double.valueOf(-5));
	640	env.put("B", Double.valueOf(3));
	641	assertEquals((Object)(Double.valueOf("-2")), cs.eval(env));
648	642	}
649	643
650	644	@Test

654	648	cs = new ExpressionParser(new StringReader("a-b AS result"));
655	649	cs.parseQueryEnvEntry();
656	650	Map<String, Object> env = new HashMap<String, Object>();
657		env.put("A", new Integer(5));
658
659		env.put("B", new Integer(1));
660		assertEquals((Object)(new Integer("4")), cs.eval(env));
661		env.put("B", new Double(1));
662		assertEquals((Object)(new Double("4")), cs.eval(env));
	651	env.put("A", Integer.valueOf(5));
	652
	653	env.put("B", Integer.valueOf(1));
	654	assertEquals((Object)(Integer.valueOf("4")), cs.eval(env));
	655	env.put("B", Double.valueOf(1));
	656	assertEquals((Object)(Double.valueOf("4")), cs.eval(env));
663	657
664	658	cs = new ExpressionParser(new StringReader("a*b AS result"));
665	659	cs.parseQueryEnvEntry();
666	660
667		env.put("B", new Integer(1));
668		assertEquals((Object)(new Integer("5")), cs.eval(env));
669		env.put("B", new Double(1));
670		assertEquals((Object)(new Double("5")), cs.eval(env));
	661	env.put("B", Integer.valueOf(1));
	662	assertEquals((Object)(Integer.valueOf("5")), cs.eval(env));
	663	env.put("B", Double.valueOf(1));
	664	assertEquals((Object)(Double.valueOf("5")), cs.eval(env));
671	665
672	666	cs = new ExpressionParser(new StringReader("a/b AS result"));
673	667	cs.parseQueryEnvEntry();
674		env.put("B", new Integer(2));
675		assertEquals((Object)(new Integer("2")), cs.eval(env));
676		env.put("B", new Double(2));
677		assertEquals((Object)(new Double("2.5")), cs.eval(env));
678
679		env.put("B", new Double(0));
	668	env.put("B", Integer.valueOf(2));
	669	assertEquals((Object)(Integer.valueOf("2")), cs.eval(env));
	670	env.put("B", Double.valueOf(2));
	671	assertEquals((Object)(Double.valueOf("2.5")), cs.eval(env));
	672
	673	env.put("B", Double.valueOf(0));
680	674	try
681	675	{
682	676	cs.eval(env);

694	688	cs = new ExpressionParser(new StringReader("A+1 AS result"));
695	689	cs.parseQueryEnvEntry();
696	690	Map<String, Object> env = new HashMap<String, Object>();
697		env.put("A", new Short("1"));
	691	env.put("A", Short.valueOf("1"));
698	692	Object o = cs.eval(env);
699	693	assertEquals(o.toString(), "2");
700	694
701	695	cs = new ExpressionParser(new StringReader("A+B AS result"));
702	696	cs.parseQueryEnvEntry();
703		env.put("A", new Short("3"));
704		env.put("B", new Short("4"));
	697	env.put("A", Short.valueOf("3"));
	698	env.put("B", Short.valueOf("4"));
705	699	o = cs.eval(env);
706	700	assertEquals(o.toString(), "7");
707	701
708	702	cs = new ExpressionParser(new StringReader("A/2 AS result"));
709	703	cs.parseQueryEnvEntry();
710		env.put("A", new Short("25"));
	704	env.put("A", Short.valueOf("25"));
711	705	o = cs.eval(env);
712	706	assertEquals(o.toString(), "12");
713	707	}

719	713	cs = new ExpressionParser(new StringReader("A+5678678678 AS result"));
720	714	cs.parseQueryEnvEntry();
721	715	Map<String, Object> env = new HashMap<String, Object>();
722		env.put("A", new Integer("1"));
	716	env.put("A", Integer.valueOf("1"));
723	717	Object o = cs.eval(env);
724	718	assertEquals(o.toString(), "5678678679");
725	719
726	720	cs = new ExpressionParser(new StringReader("A-50000000000 AS result"));
727	721	cs.parseQueryEnvEntry();
728		env.put("A", new Long("120000000000"));
	722	env.put("A", Long.valueOf("120000000000"));
729	723	o = cs.eval(env);
730	724	assertEquals(o.toString(), "70000000000");
731	725
732	726	cs = new ExpressionParser(new StringReader("A*5000000000 AS result"));
733	727	cs.parseQueryEnvEntry();
734		env.put("A", new Integer("3"));
	728	env.put("A", Integer.valueOf("3"));
735	729	o = cs.eval(env);
736	730	assertEquals(o.toString(), "15000000000");
737	731
738	732	cs = new ExpressionParser(new StringReader("A*10000L AS result"));
739	733	cs.parseQueryEnvEntry();
740		env.put("A", new Integer("1000000"));
	734	env.put("A", Integer.valueOf("1000000"));
741	735	o = cs.eval(env);
742	736	assertEquals(o.toString(), "10000000000");
743	737
744	738	cs = new ExpressionParser(new StringReader("A/10 AS result"));
745	739	cs.parseQueryEnvEntry();
746		env.put("A", new Long("-1234567891230"));
	740	env.put("A", Long.valueOf("-1234567891230"));
747	741	o = cs.eval(env);
748	742	assertEquals(o.toString(), "-123456789123");
749	743	}

755	749	cs = new ExpressionParser(new StringReader("CURRENT_DATE AS now"));
756	750	cs.parseQueryEnvEntry();
757	751	Map<String, Object> env = new HashMap<String, Object>();
758		env.put(StringConverter.COLUMN_NAME, new StringConverter("yyyy-mm-dd", "HH:mm:ss", "yyyy-MM-dd HH:mm:ss", "UTC"));
	752	env.put(StringConverter.COLUMN_NAME, new StringConverter("yyyy-mm-dd", "HH:mm:ss", "yyyy-MM-dd HH:mm:ss", "UTC", false));
759	753
760	754	// Protect against unlikely situation of test running over date change at midnight.
761	755	String date1 = new Date(System.currentTimeMillis()).toString();

785	779	cs.parseQueryEnvEntry();
786	780	env.put("EXPIRYDATE", Date.valueOf("2011-11-24"));
787	781	o = cs.eval(env);
788		assertEquals(o, new Integer(23));
	782	assertEquals(o, Integer.valueOf(23));
789	783
790	784	cs = new ExpressionParser(new StringReader("ENDDATE - STARTDATE + 1 as result"));
791	785	cs.parseQueryEnvEntry();
792	786	env.put("STARTDATE", Date.valueOf("2011-11-22"));
793	787	env.put("ENDDATE", Date.valueOf("2011-11-24"));
794	788	o = cs.eval(env);
795		assertEquals(o, new Integer(3));
	789	assertEquals(o, Integer.valueOf(3));
796	790	}
797	791
798	792	@Test

+59

-17

src/test/java/org/relique/jdbc/csv/TestStringConverter.java less more

30	30
31	31	import org.junit.BeforeClass;
32	32	import org.junit.Test;
33		import org.relique.jdbc.csv.StringConverter;
34	33
35	34	/**
36	35	* This class is used to test the SqlParser class.

51	50	@Test
52	51	public void testParseDateFixedSize()
53	52	{
54		StringConverter sc = new StringConverter("dd-mm-yyyy", "", "", "");
	53	StringConverter sc = new StringConverter("dd-mm-yyyy", "", "", "", false);
55	54
56	55	Date got, expect;
57	56

67	66	@Test
68	67	public void testParseDateVariableSize()
69	68	{
70		StringConverter sc = new StringConverter("m-d-yyyy", "", "", "");
	69	StringConverter sc = new StringConverter("m-d-yyyy", "", "", "", false);
71	70
72	71	Date got, expect;
73	72

83	82	@Test
84	83	public void testParseDateVariableSizeYMD()
85	84	{
86		StringConverter sc = new StringConverter("yyyy-m-d", "", "", "");
	85	StringConverter sc = new StringConverter("yyyy-m-d", "", "", "", false);
87	86
88	87	Date got, expect;
89	88

99	98	@Test
100	99	public void testParseDateVariableSizeMYD()
101	100	{
102		StringConverter sc = new StringConverter("m-yyyy-d", "", "", "");
	101	StringConverter sc = new StringConverter("m-yyyy-d", "", "", "", false);
103	102
104	103	Date got, expect;
105	104

115	114	@Test
116	115	public void testParseDateNamedMonth()
117	116	{
118		StringConverter sc = new StringConverter("dd-MMM-yyyy", "", "", "", Locale.ENGLISH);
	117	StringConverter sc = new StringConverter("dd-MMM-yyyy", "", "", "", Locale.ENGLISH, false);
119	118
120	119	Date got, expect;
121	120

131	130	@Test
132	131	public void testParseDateNamedDay()
133	132	{
134		StringConverter sc = new StringConverter("EEE, MMM d, yyyy", "", "", "", Locale.ENGLISH);
	133	StringConverter sc = new StringConverter("EEE, MMM d, yyyy", "", "", "", Locale.ENGLISH, false);
135	134
136	135	Date got, expect;
137	136

147	146	@Test
148	147	public void testParseTimeMilliseconds()
149	148	{
150		StringConverter sc = new StringConverter("", "HH:mm:ss.SSS", "", "", Locale.ENGLISH);
	149	StringConverter sc = new StringConverter("", "HH:mm:ss.SSS", "", "", Locale.ENGLISH, false);
151	150
152	151	Time got, expect;
153	152

162	161	public void testParseTimestampWithTimeZoneGuadeloupe()
163	162	{
164	163	// Guadeloupe lies 4 hours behind UTC, no daylight savings
165		StringConverter sc = new StringConverter("", "", "yyyy-MM-dd HH:mm:ss", "America/Guadeloupe");
	164	StringConverter sc = new StringConverter("", "", "yyyy-MM-dd HH:mm:ss", "America/Guadeloupe", false);
166	165	Timestamp got;
167	166
168	167	got = sc.parseTimestamp("2010-01-01 12:00:00");

176	175	public void testParseDateWithTimeZoneYakutsk()
177	176	{
178	177	// in January Yakutsk lies 9 hours ahead of UTC
179		StringConverter sc = new StringConverter("", "", "yyyy-MM-dd HH:mm:ss", "Asia/Yakutsk");
	178	StringConverter sc = new StringConverter("", "", "yyyy-MM-dd HH:mm:ss", "Asia/Yakutsk", false);
180	179	Timestamp got;
181	180
182	181	got = sc.parseTimestamp("2010-01-01 12:00:00");

191	190	public void testParseDateWithTimeZoneSantiago()
192	191	{
193	192	// in January Santiago lies 3 hours behind of UTC
194		StringConverter sc = new StringConverter("", "", "yyyy-MM-dd HH:mm:ss", "America/Santiago");
	193	StringConverter sc = new StringConverter("", "", "yyyy-MM-dd HH:mm:ss", "America/Santiago", false);
195	194	Timestamp got;
196	195
197	196	got = sc.parseTimestamp("2010-01-01 12:00:00");

206	205	public void testParseDateWithTimeZoneAthens()
207	206	{
208	207	// in January Athens lies 2 hours ahead of UTC
209		StringConverter sc = new StringConverter("", "", "yyyy-MM-dd HH:mm:ss", "Europe/Athens");
	208	StringConverter sc = new StringConverter("", "", "yyyy-MM-dd HH:mm:ss", "Europe/Athens", false);
210	209	Timestamp got;
211	210
212	211	got = sc.parseTimestamp("2010-01-01 12:00:00");

221	220	public void testParseDateWithTimeZoneDefaultJanuary()
222	221	{
223	222	// defaulting to UTC
224		StringConverter sc = new StringConverter("", "", "yyyy-MM-dd HH:mm:ss", "");
	223	StringConverter sc = new StringConverter("", "", "yyyy-MM-dd HH:mm:ss", "", false);
225	224	Timestamp got;
226	225
227	226	got = sc.parseTimestamp("2010-01-01 12:00:00");

232	231	public void testParseDateWithTimeZoneDefaultJuly()
233	232	{
234	233	// defaulting to UTC
235		StringConverter sc = new StringConverter("", "", "yyyy-MM-dd HH:mm:ss", "");
	234	StringConverter sc = new StringConverter("", "", "yyyy-MM-dd HH:mm:ss", "", false);
236	235	Timestamp got;
237	236
238	237	got = sc.parseTimestamp("2010-07-01 12:00:00");

243	242	public void testParseDateWithTimeZoneUTCJanuary()
244	243	{
245	244	// explicit UTC
246		StringConverter sc = new StringConverter("", "", "yyyy-MM-dd HH:mm:ss", "UTC");
	245	StringConverter sc = new StringConverter("", "", "yyyy-MM-dd HH:mm:ss", "UTC", false);
247	246	Timestamp got;
248	247
249	248	got = sc.parseTimestamp("2010-01-01 12:00:00");

254	253	public void testParseDateWithTimeZoneUTCJuly()
255	254	{
256	255	// explicit UTC
257		StringConverter sc = new StringConverter("", "", "yyyy-MM-dd HH:mm:ss", "UTC");
	256	StringConverter sc = new StringConverter("", "", "yyyy-MM-dd HH:mm:ss", "UTC", false);
258	257	Timestamp got;
259	258
260	259	got = sc.parseTimestamp("2010-07-01 12:00:00");

265	264	public void testParseTimestampWithFormat()
266	265	{
267	266	// explicit UTC
268		StringConverter sc = new StringConverter("", "", "dd-MMM-yy hh.mm.ss.000000 aa", "UTC");
	267	StringConverter sc = new StringConverter("", "", "dd-MMM-yy hh.mm.ss.000000 aa", "UTC", false);
269	268	Timestamp got;
270	269
271	270	got = sc.parseTimestamp("25-NOV-13 01.29.07.000000 PM");
272	271	assertEquals("2013-11-25 13:29:07", toUTC.format(got));
273	272	}
	273
	274	@Test
	275	public void testUseDateTimeFormatter()
	276	{
	277	// Test parsing and formatting using java.time.DateTimeFormatter
	278	StringConverter sc = new StringConverter("dd-LLLL-yyyy", "HH:mm", "yyyy-MM-dd HH:mm:ss.SSS", "UTC", true);
	279
	280	Date gotDate = sc.parseDate("25-OCTOBER-2020");
	281	Date expectDate = java.sql.Date.valueOf("2020-10-25");
	282	assertEquals(expectDate, gotDate);
	283
	284	Time gotTime = sc.parseTime("19:51");
	285	Time expectTime = java.sql.Time.valueOf("19:51:00");
	286	assertEquals(expectTime, gotTime);
	287
	288	Timestamp gotTimestamp = sc.parseTimestamp("2019-09-04 13:45:48.616");
	289	assertEquals("2019-09-04 13:45:48", toUTC.format(gotTimestamp));
	290
	291	String gotFormatted = sc.formatTimestamp(gotTimestamp);
	292	assertEquals("2019-09-04 13:45:48.616", gotFormatted);
	293	}
	294
	295	@Test
	296	public void testUseDateTimeFormatterWithTimeZoneMontreal()
	297	{
	298	// Test parsing and formatting using java.time.DateTimeFormatter
	299	StringConverter sc = new StringConverter("dd LLLL yyyy", "HH:mm:ss", "dd.MM.yyyy HH:mm:ss", "America/Montreal", Locale.CANADA_FRENCH, true);
	300
	301	Date gotDate = sc.parseDate("31 janvier 2020");
	302	Date expectDate = java.sql.Date.valueOf("2020-01-31");
	303	assertEquals(expectDate, gotDate);
	304
	305	Time gotTime = sc.parseTime("07:31:59");
	306	Time expectTime = java.sql.Time.valueOf("07:31:59");
	307	assertEquals(expectTime, gotTime);
	308
	309	// in November Montreal lies 5 hours behind UTC
	310	Timestamp gotTimestamp = sc.parseTimestamp("29.11.2020 06:02:00");
	311	assertEquals("2020-11-29 11:02:00", toUTC.format(gotTimestamp));
	312
	313	String gotFormatted = sc.formatTimestamp(gotTimestamp);
	314	assertEquals("29.11.2020 06:02:00", gotFormatted);
	315	}
274	316	}

+225

-229

src/test/java/org/relique/jdbc/csv/TestSubQuery.java less more

50	50	try
51	51	{
52	52	Class.forName("org.relique.jdbc.csv.CsvDriver");
53		}
	53	}
54	54	catch (ClassNotFoundException e)
55	55	{
56	56	fail("Driver is not in the CLASSPATH -> " + e);

78	78	props.put("commentChar", "#");
79	79	props.put("charset", "UTF-8");
80	80
81		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
82
83		Statement stmt = conn.createStatement();
84
85		ResultSet rs1 = stmt.executeQuery("SELECT (SELECT BANK_NAME FROM banks WHERE BLZ=FROM_BLZ), AMOUNT FROM transactions");
86		assertTrue(rs1.next());
87		assertEquals("The BANK_NAME is wrong", "Postbank (Berlin)", rs1.getString(1));
88		assertTrue("The AMOUNT is wrong", fuzzyEquals(250.0, rs1.getDouble(2)));
89		assertTrue(rs1.next());
90		assertEquals("The BANK_NAME is wrong", "Postbank (Berlin)", rs1.getString(1));
91		assertTrue(rs1.next());
92		assertEquals("The BANK_NAME is wrong", "Postbank (Berlin)", rs1.getString(1));
93		assertTrue(rs1.next());
94		assertEquals("The BANK_NAME is wrong", "Bank f\u00FCr Sozialwirtschaft (Berlin)", rs1.getString(1));
95		assertTrue(rs1.next());
96		assertEquals("The BANK_NAME is wrong", "Postbank (Berlin)", rs1.getString(1));
97
98		rs1.close();
99		stmt.close();
100		}
101
	81	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
	82
	83	Statement stmt = conn.createStatement();
	84
	85	ResultSet rs1 = stmt.executeQuery("SELECT (SELECT BANK_NAME FROM banks WHERE BLZ=FROM_BLZ), AMOUNT FROM transactions"))
	86	{
	87	assertTrue(rs1.next());
	88	assertEquals("The BANK_NAME is wrong", "Postbank (Berlin)", rs1.getString(1));
	89	assertTrue("The AMOUNT is wrong", fuzzyEquals(250.0, rs1.getDouble(2)));
	90	assertTrue(rs1.next());
	91	assertEquals("The BANK_NAME is wrong", "Postbank (Berlin)", rs1.getString(1));
	92	assertTrue(rs1.next());
	93	assertEquals("The BANK_NAME is wrong", "Postbank (Berlin)", rs1.getString(1));
	94	assertTrue(rs1.next());
	95	assertEquals("The BANK_NAME is wrong", "Bank f\u00FCr Sozialwirtschaft (Berlin)", rs1.getString(1));
	96	assertTrue(rs1.next());
	97	assertEquals("The BANK_NAME is wrong", "Postbank (Berlin)", rs1.getString(1));
	98	}
	99	}
	100
102	101	@Test
103	102	public void testInvalidTable() throws SQLException
104	103	{

110	109	props.put("commentChar", "#");
111	110	props.put("charset", "UTF-8");
112	111
113		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
114
115		Statement stmt = conn.createStatement();
116
117		try
118		{
119		ResultSet rs1 = stmt.executeQuery("SELECT (SELECT BANK_NAME FROM XXXX), AMOUNT FROM transactions");
120		if (rs1.next())
121		rs1.getString(1);
122		fail("Should raise a java.sqlSQLException");
123		}
124		catch (SQLException e)
125		{
126		assertTrue(e.getMessage().contains(CsvResources.getString("fileNotFound")));
127		assertTrue(e.getMessage().contains("XXXX"));
128		}
	112	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
	113
	114	Statement stmt = conn.createStatement())
	115	{
	116	try
	117	{
	118	ResultSet rs1 = stmt.executeQuery("SELECT (SELECT BANK_NAME FROM XXXX), AMOUNT FROM transactions");
	119	if (rs1.next())
	120	rs1.getString(1);
	121	fail("Should raise a java.sqlSQLException");
	122	}
	123	catch (SQLException e)
	124	{
	125	assertTrue(e.getMessage().contains(CsvResources.getString("fileNotFound")));
	126	assertTrue(e.getMessage().contains("XXXX"));
	127	}
	128	}
129	129	}
130	130
131	131	@Test

139	139	props.put("commentChar", "#");
140	140	props.put("charset", "UTF-8");
141	141
142		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
143
144		Statement stmt = conn.createStatement();
145
146		try
147		{
148		ResultSet rs1 = stmt.executeQuery("SELECT (SELECT XXXX FROM banks WHERE BLZ=FROM_BLZ), AMOUNT FROM transactions");
149		if (rs1.next())
150		rs1.getString(1);
151		fail("Should raise a java.sqlSQLException");
152		}
153		catch (SQLException e)
154		{
155		assertTrue(e.getMessage().contains(CsvResources.getString("invalidColumnName")));
156		assertTrue(e.getMessage().contains("XXXX"));
157		}
	142	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
	143
	144	Statement stmt = conn.createStatement())
	145	{
	146	try
	147	{
	148	ResultSet rs1 = stmt.executeQuery("SELECT (SELECT XXXX FROM banks WHERE BLZ=FROM_BLZ), AMOUNT FROM transactions");
	149	if (rs1.next())
	150	rs1.getString(1);
	151	fail("Should raise a java.sqlSQLException");
	152	}
	153	catch (SQLException e)
	154	{
	155	assertTrue(e.getMessage().contains(CsvResources.getString("invalidColumnName")));
	156	assertTrue(e.getMessage().contains("XXXX"));
	157	}
	158	}
158	159	}
159	160
160	161	@Test

168	169	props.put("commentChar", "#");
169	170	props.put("charset", "UTF-8");
170	171
171		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
172
173		Statement stmt = conn.createStatement();
174
175		try
176		{
177		ResultSet rs1 = stmt.executeQuery("SELECT (SELECT BANK_NAME, BANK_NAME B2 FROM banks WHERE BLZ=FROM_BLZ), AMOUNT FROM transactions");
178		if (rs1.next())
179		rs1.getString(1);
180		fail("Should raise a java.sqlSQLException");
181		}
182		catch (SQLException e)
183		{
184		assertEquals("java.sql.SQLException: " + CsvResources.getString("subqueryOneColumn"), "" + e);
185		}
186		}
187
	172	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
	173
	174	Statement stmt = conn.createStatement())
	175	{
	176	try
	177	{
	178	ResultSet rs1 = stmt.executeQuery("SELECT (SELECT BANK_NAME, BANK_NAME B2 FROM banks WHERE BLZ=FROM_BLZ), AMOUNT FROM transactions");
	179	if (rs1.next())
	180	rs1.getString(1);
	181	fail("Should raise a java.sqlSQLException");
	182	}
	183	catch (SQLException e)
	184	{
	185	assertEquals("java.sql.SQLException: " + CsvResources.getString("subqueryOneColumn"), "" + e);
	186	}
	187	}
	188	}
	189
188	190	@Test
189	191	public void testMoreThanOneRow() throws SQLException
190	192	{

197	199	props.put("commentChar", "#");
198	200	props.put("charset", "UTF-8");
199	201
200		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
201
202		Statement stmt = conn.createStatement();
203
204		try
205		{
206		ResultSet rs1 = stmt.executeQuery("SELECT (SELECT BANK_NAME FROM banks), AMOUNT FROM transactions");
207		if (rs1.next())
208		rs1.getString(1);
209		fail("Should raise a java.sqlSQLException");
210		}
211		catch (SQLException e)
212		{
213		assertEquals("java.sql.SQLException: " + CsvResources.getString("subqueryOneRow"), "" + e);
214		}
215		}
216
	202	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
	203
	204	Statement stmt = conn.createStatement())
	205	{
	206	try
	207	{
	208	ResultSet rs1 = stmt.executeQuery("SELECT (SELECT BANK_NAME FROM banks), AMOUNT FROM transactions");
	209	if (rs1.next())
	210	rs1.getString(1);
	211	fail("Should raise a java.sqlSQLException");
	212	}
	213	catch (SQLException e)
	214	{
	215	assertEquals("java.sql.SQLException: " + CsvResources.getString("subqueryOneRow"), "" + e);
	216	}
	217	}
	218	}
	219
217	220	@Test
218	221	public void testNoMatch() throws SQLException
219	222	{
220		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath);
221
222		Statement stmt = conn.createStatement();
223
224		ResultSet rs1 = stmt.executeQuery("SELECT ID, NAME, (SELECT NAME FROM sample2 s2 WHERE s2.ID=s1.ID) FROM sample s1");
225		assertTrue(rs1.next());
226		assertEquals("The ID is wrong", "Q123", rs1.getString(1));
227		assertEquals("The Name is wrong", "\"S,\"", rs1.getString(2));
228		// No match so subquery returns null for this row.
229		assertNull("The Subquery is wrong", rs1.getString(3));
230		assertTrue(rs1.next());
231		assertEquals("The ID is wrong", "A123", rs1.getString(1));
232		assertEquals("The Name is wrong", "Jonathan Ackerman", rs1.getString(2));
233		assertEquals("The Subquery is wrong", "Aman", rs1.getString(3));
234		assertTrue(rs1.next());
235		assertEquals("The ID is wrong", "B234", rs1.getString(1));
236		assertEquals("The Name is wrong", "Grady O'Neil", rs1.getString(2));
237		// No match so subquery returns null for this row.
238		assertNull("The Subquery is wrong", rs1.getString(3));
239
240		rs1.close();
241		stmt.close();
242		}
243
	223	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath);
	224
	225	Statement stmt = conn.createStatement();
	226
	227	ResultSet rs1 = stmt.executeQuery("SELECT ID, NAME, (SELECT NAME FROM sample2 s2 WHERE s2.ID=s1.ID) FROM sample s1"))
	228	{
	229	assertTrue(rs1.next());
	230	assertEquals("The ID is wrong", "Q123", rs1.getString(1));
	231	assertEquals("The Name is wrong", "\"S,\"", rs1.getString(2));
	232	// No match so subquery returns null for this row.
	233	assertNull("The Subquery is wrong", rs1.getString(3));
	234	assertTrue(rs1.next());
	235	assertEquals("The ID is wrong", "A123", rs1.getString(1));
	236	assertEquals("The Name is wrong", "Jonathan Ackerman", rs1.getString(2));
	237	assertEquals("The Subquery is wrong", "Aman", rs1.getString(3));
	238	assertTrue(rs1.next());
	239	assertEquals("The ID is wrong", "B234", rs1.getString(1));
	240	assertEquals("The Name is wrong", "Grady O'Neil", rs1.getString(2));
	241	// No match so subquery returns null for this row.
	242	assertNull("The Subquery is wrong", rs1.getString(3));
	243	}
	244	}
	245
244	246	@Test
245	247	public void testAggregateFunction() throws SQLException
246	248	{

252	254	props.put("commentChar", "#");
253	255	props.put("charset", "UTF-8");
254	256
255		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
256
257		Statement stmt = conn.createStatement();
258
259		ResultSet rs1 = stmt.executeQuery("SELECT BANK_NAME, (SELECT COUNT(*) FROM transactions WHERE BLZ=FROM_BLZ) COUNT_ FROM banks");
260		assertTrue(rs1.next());
261		assertEquals("The BANK_NAME is wrong", "Bundesbank (Berlin)", rs1.getString(1));
262		assertEquals("The Subquery is wrong", 0, rs1.getInt(2));
263		assertTrue(rs1.next());
264		assertEquals("The BANK_NAME is wrong", "Postbank (Berlin)", rs1.getString(1));
265		assertEquals("The Subquery is wrong", 5, rs1.getInt(2));
266		assertTrue(rs1.next());
267		assertEquals("The BANK_NAME is wrong", "SEB (Berlin)", rs1.getString(1));
268		assertEquals("The Subquery is wrong", 0, rs1.getInt(2));
269
270		rs1.close();
271		stmt.close();
272		}
273
	257	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
	258
	259	Statement stmt = conn.createStatement();
	260
	261	ResultSet rs1 = stmt.executeQuery("SELECT BANK_NAME, (SELECT COUNT(*) FROM transactions WHERE BLZ=FROM_BLZ) COUNT_ FROM banks"))
	262	{
	263	assertTrue(rs1.next());
	264	assertEquals("The BANK_NAME is wrong", "Bundesbank (Berlin)", rs1.getString(1));
	265	assertEquals("The Subquery is wrong", 0, rs1.getInt(2));
	266	assertTrue(rs1.next());
	267	assertEquals("The BANK_NAME is wrong", "Postbank (Berlin)", rs1.getString(1));
	268	assertEquals("The Subquery is wrong", 5, rs1.getInt(2));
	269	assertTrue(rs1.next());
	270	assertEquals("The BANK_NAME is wrong", "SEB (Berlin)", rs1.getString(1));
	271	assertEquals("The Subquery is wrong", 0, rs1.getInt(2));
	272	}
	273	}
	274
274	275	@Test
275	276	public void testOrderBy() throws SQLException
276	277	{

282	283	props.put("commentChar", "#");
283	284	props.put("charset", "UTF-8");
284	285
285		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
286
287		Statement stmt = conn.createStatement();
288
289		ResultSet rs1 = stmt.executeQuery("SELECT BANK_NAME, (SELECT COUNT(*) FROM transactions WHERE BLZ=FROM_BLZ) COUNT_ FROM banks ORDER BY COUNT_ DESC");
290		assertTrue(rs1.next());
291		assertEquals("The BANK_NAME is wrong", "Postbank (Berlin)", rs1.getString(1));
292		assertEquals("The Subquery is wrong", 5, rs1.getInt(2));
293		assertTrue(rs1.next());
294		assertEquals("The BANK_NAME is wrong", "Bank f\u00FCr Sozialwirtschaft (Berlin)", rs1.getString(1));
295		assertEquals("The Subquery is wrong", 3, rs1.getInt(2));
296		assertTrue(rs1.next());
297		assertEquals("The BANK_NAME is wrong", "BHF-BANK (Berlin)", rs1.getString(1));
298		assertEquals("The Subquery is wrong", 1, rs1.getInt(2));
299
300		rs1.close();
301		stmt.close();
	286	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
	287
	288	Statement stmt = conn.createStatement();
	289
	290	ResultSet rs1 = stmt.executeQuery("SELECT BANK_NAME, (SELECT COUNT(*) FROM transactions WHERE BLZ=FROM_BLZ) COUNT_ FROM banks ORDER BY COUNT_ DESC"))
	291	{
	292	assertTrue(rs1.next());
	293	assertEquals("The BANK_NAME is wrong", "Postbank (Berlin)", rs1.getString(1));
	294	assertEquals("The Subquery is wrong", 5, rs1.getInt(2));
	295	assertTrue(rs1.next());
	296	assertEquals("The BANK_NAME is wrong", "Bank f\u00FCr Sozialwirtschaft (Berlin)", rs1.getString(1));
	297	assertEquals("The Subquery is wrong", 3, rs1.getInt(2));
	298	assertTrue(rs1.next());
	299	assertEquals("The BANK_NAME is wrong", "BHF-BANK (Berlin)", rs1.getString(1));
	300	assertEquals("The Subquery is wrong", 1, rs1.getInt(2));
	301	}
302	302	}
303	303
304	304	@Test

307	307	Properties props = new Properties();
308	308	props.put("columnTypes", "Integer,Integer,Integer,Date,Time");
309	309
310		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
311
312		Statement stmt = conn.createStatement();
313
314		ResultSet rs1 = stmt.executeQuery("select AccountNo from Purchase where CampaignNo=(select max(CampaignNo) from Purchase)");
315		assertTrue(rs1.next());
316		assertEquals("The AccountNo is wrong", 22021, rs1.getInt(1));
317		assertFalse(rs1.next());
318
319		rs1.close();
320		stmt.close();
	310	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
	311
	312	Statement stmt = conn.createStatement();
	313
	314	ResultSet rs1 = stmt.executeQuery("select AccountNo from Purchase where CampaignNo=(select max(CampaignNo) from Purchase)"))
	315	{
	316	assertTrue(rs1.next());
	317	assertEquals("The AccountNo is wrong", 22021, rs1.getInt(1));
	318	assertFalse(rs1.next());
	319	}
321	320	}
322	321
323	322	@Test
324	323	public void testInSubQuery() throws SQLException
325	324	{
326	325	Properties props = new Properties();
327		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
328
329		Statement stmt = conn.createStatement();
330
331		ResultSet rs1 = stmt.executeQuery("select NAME from sample5 where ID in (select ID from sample4)");
332		assertTrue(rs1.next());
333		assertEquals("The NAME is wrong", "Juan Pablo Morales", rs1.getString(1));
334		assertTrue(rs1.next());
335		assertEquals("The NAME is wrong", "Mauricio Hernandez", rs1.getString(1));
336		assertTrue(rs1.next());
337		assertEquals("The NAME is wrong", "Maria Cristina Lucero", rs1.getString(1));
338		assertTrue(rs1.next());
339		assertEquals("The NAME is wrong", "Felipe Grajales", rs1.getString(1));
340		assertFalse(rs1.next());
341
342		rs1.close();
343		stmt.close();
	326	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
	327
	328	Statement stmt = conn.createStatement();
	329
	330	ResultSet rs1 = stmt.executeQuery("select NAME from sample5 where ID in (select ID from sample4)"))
	331	{
	332	assertTrue(rs1.next());
	333	assertEquals("The NAME is wrong", "Juan Pablo Morales", rs1.getString(1));
	334	assertTrue(rs1.next());
	335	assertEquals("The NAME is wrong", "Mauricio Hernandez", rs1.getString(1));
	336	assertTrue(rs1.next());
	337	assertEquals("The NAME is wrong", "Maria Cristina Lucero", rs1.getString(1));
	338	assertTrue(rs1.next());
	339	assertEquals("The NAME is wrong", "Felipe Grajales", rs1.getString(1));
	340	assertFalse(rs1.next());
	341	}
344	342	}
345	343
346	344	@Test
347	345	public void testInSubQueryNoMatch() throws SQLException
348	346	{
349	347	Properties props = new Properties();
350		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
351
352		Statement stmt = conn.createStatement();
353
354		ResultSet rs1 = stmt.executeQuery("select NAME from sample5 where ID in (select AccountNo from Purchase where CampaignNo='XXXX')");
355		assertFalse(rs1.next());
356
357		rs1.close();
358		stmt.close();
	348	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
	349
	350	Statement stmt = conn.createStatement();
	351
	352	ResultSet rs1 = stmt.executeQuery("select NAME from sample5 where ID in (select AccountNo from Purchase where CampaignNo='XXXX')"))
	353	{
	354	assertFalse(rs1.next());
	355	}
359	356	}
360	357
361	358	@Test
362	359	public void testExistsSubQuery() throws SQLException
363	360	{
364	361	Properties props = new Properties();
365		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
366
367		Statement stmt = conn.createStatement();
368
369		ResultSet rs1 = stmt.executeQuery("select EXTRA_FIELD from sample where exists (select 1 from sample2 where sample2.id=sample.id)");
370		assertTrue(rs1.next());
371		assertEquals("The EXTRA_FIELD is wrong", "A", rs1.getString(1));
372		assertFalse(rs1.next());
373
374		rs1.close();
375		stmt.close();
	362	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
	363
	364	Statement stmt = conn.createStatement();
	365
	366	ResultSet rs1 = stmt.executeQuery("select EXTRA_FIELD from sample where exists (select 1 from sample2 where sample2.id=sample.id)"))
	367	{
	368	assertTrue(rs1.next());
	369	assertEquals("The EXTRA_FIELD is wrong", "A", rs1.getString(1));
	370	assertFalse(rs1.next());
	371	}
376	372	}
377	373
378	374	@Test
379	375	public void testNotExistsSubQuery() throws SQLException
380	376	{
381	377	Properties props = new Properties();
382		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
383
384		Statement stmt = conn.createStatement();
385
386		ResultSet rs1 = stmt.executeQuery("select EXTRA_FIELD from sample where not exists (select 1 from sample2 where sample2.id=sample.id)");
387		assertTrue(rs1.next());
388		assertEquals("The EXTRA_FIELD is wrong", "F", rs1.getString(1));
389		assertTrue(rs1.next());
390		assertEquals("The EXTRA_FIELD is wrong", "B", rs1.getString(1));
391		assertTrue(rs1.next());
392		assertEquals("The EXTRA_FIELD is wrong", "C", rs1.getString(1));
393		assertTrue(rs1.next());
394		assertEquals("The EXTRA_FIELD is wrong", "E", rs1.getString(1));
395		assertTrue(rs1.next());
396		assertEquals("The EXTRA_FIELD is wrong", "G", rs1.getString(1));
397		assertFalse(rs1.next());
398
399		rs1.close();
400		stmt.close();
	378	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
	379
	380	Statement stmt = conn.createStatement();
	381
	382	ResultSet rs1 = stmt.executeQuery("select EXTRA_FIELD from sample where not exists (select 1 from sample2 where sample2.id=sample.id)"))
	383	{
	384	assertTrue(rs1.next());
	385	assertEquals("The EXTRA_FIELD is wrong", "F", rs1.getString(1));
	386	assertTrue(rs1.next());
	387	assertEquals("The EXTRA_FIELD is wrong", "B", rs1.getString(1));
	388	assertTrue(rs1.next());
	389	assertEquals("The EXTRA_FIELD is wrong", "C", rs1.getString(1));
	390	assertTrue(rs1.next());
	391	assertEquals("The EXTRA_FIELD is wrong", "E", rs1.getString(1));
	392	assertTrue(rs1.next());
	393	assertEquals("The EXTRA_FIELD is wrong", "G", rs1.getString(1));
	394	assertFalse(rs1.next());
	395	}
401	396	}
402	397
403	398	@Test
404	399	public void testDerivedTable() throws SQLException
405	400	{
406	401	Properties props = new Properties();
407		Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
408
409		Statement stmt = conn.createStatement();
410
411		try
412		{
413		ResultSet rs1 = stmt.executeQuery("SELECT ID FROM (SELECT ID FROM sample) AS X");
414		if (rs1.next())
415		rs1.getString(1);
416		fail("Should raise a java.sqlSQLException");
417		}
418		catch (SQLException e)
419		{
420		assertTrue(e.getMessage().contains(CsvResources.getString("derivedTableNotSupported")));
	402	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:" + filePath, props);
	403
	404	Statement stmt = conn.createStatement())
	405	{
	406	try
	407	{
	408	ResultSet rs1 = stmt.executeQuery("SELECT ID FROM (SELECT ID FROM sample) AS X");
	409	if (rs1.next())
	410	rs1.getString(1);
	411	fail("Should raise a java.sqlSQLException");
	412	}
	413	catch (SQLException e)
	414	{
	415	assertTrue(e.getMessage().contains(CsvResources.getString("derivedTableNotSupported")));
	416	}
421	417	}
422	418	}
423	419	}

+99

-97

src/test/java/org/relique/jdbc/csv/TestZipFiles.java less more

70	70	@Test
71	71	public void testConnectionName() throws SQLException
72	72	{
73		Connection conn = DriverManager.getConnection("jdbc:relique:csv:zip:"
	73	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:zip:"
	74	+ filePath + File.separator + TEST_ZIP_FILENAME_1))
	75	{
	76	String url = conn.getMetaData().getURL();
	77	assertTrue(url.startsWith("jdbc:relique:csv:zip:"));
	78	assertTrue(url.endsWith(TEST_ZIP_FILENAME_1));
	79	}
	80	}
	81
	82	@Test
	83	public void testSelect() throws SQLException
	84	{
	85	Properties props = new Properties();
	86	props.put("columnTypes", "Short,String,String,Short,Short,Short");
	87
	88	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:zip:"
	89	+ filePath + File.separator + TEST_ZIP_FILENAME_1, props);
	90	Statement stmt = conn.createStatement();
	91	ResultSet results = stmt.executeQuery("SELECT * FROM medals2004"))
	92	{
	93	assertTrue(results.next());
	94	assertEquals("The YEAR is wrong", 2004, results.getShort(1));
	95	assertEquals("The COUNTRY is wrong", "United States", results.getString(2));
	96	assertEquals("The CODE is wrong", "USA", results.getString(3));
	97	assertEquals("The GOLD is wrong", 36, results.getShort(4));
	98	assertTrue(results.next());
	99	assertEquals("The YEAR is wrong", 2004, results.getShort(1));
	100	assertEquals("The COUNTRY is wrong", "China", results.getString(2));
	101	assertEquals("The CODE is wrong", "CHN", results.getString(3));
	102	assertEquals("The GOLD is wrong", 32, results.getShort(4));
	103	}
	104	}
	105
	106	@Test
	107	public void testListTables() throws SQLException
	108	{
	109	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:zip:"
74	110	+ filePath + File.separator + TEST_ZIP_FILENAME_1);
75		String url = conn.getMetaData().getURL();
76		assertTrue(url.startsWith("jdbc:relique:csv:zip:"));
77		assertTrue(url.endsWith(TEST_ZIP_FILENAME_1));
78		}
79
80		@Test
81		public void testSelect() throws SQLException
82		{
83		Properties props = new Properties();
84		props.put("columnTypes", "Short,String,String,Short,Short,Short");
85
86		Connection conn = DriverManager.getConnection("jdbc:relique:csv:zip:"
87		+ filePath + File.separator + TEST_ZIP_FILENAME_1, props);
88
89		Statement stmt = conn.createStatement();
90
91		ResultSet results = stmt.executeQuery("SELECT * FROM medals2004");
92		assertTrue(results.next());
93		assertEquals("The YEAR is wrong", 2004, results.getShort(1));
94		assertEquals("The COUNTRY is wrong", "United States", results.getString(2));
95		assertEquals("The CODE is wrong", "USA", results.getString(3));
96		assertEquals("The GOLD is wrong", 36, results.getShort(4));
97		assertTrue(results.next());
98		assertEquals("The YEAR is wrong", 2004, results.getShort(1));
99		assertEquals("The COUNTRY is wrong", "China", results.getString(2));
100		assertEquals("The CODE is wrong", "CHN", results.getString(3));
101		assertEquals("The GOLD is wrong", 32, results.getShort(4));
102		}
103
104		@Test
105		public void testListTables() throws SQLException
106		{
107		Connection conn = DriverManager.getConnection("jdbc:relique:csv:zip:"
	111	ResultSet results = conn.getMetaData().getTables(null, null, "%", null))
	112	{
	113	assertTrue(results.next());
	114	assertEquals("The TABLE_NAME is wrong", "medals2004", results.getString("TABLE_NAME"));
	115	assertTrue(results.next());
	116	assertEquals("The TABLE_NAME is wrong", "medals2008", results.getString("TABLE_NAME"));
	117	assertFalse(results.next());
	118	}
	119	}
	120
	121	@Test
	122	public void testBadTableNameFails() throws SQLException
	123	{
	124	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:zip:"
108	125	+ filePath + File.separator + TEST_ZIP_FILENAME_1);
109
110		ResultSet results = conn.getMetaData().getTables(null, null, "%", null);
111		assertTrue(results.next());
112		assertEquals("The TABLE_NAME is wrong", "medals2004", results.getString("TABLE_NAME"));
113		assertTrue(results.next());
114		assertEquals("The TABLE_NAME is wrong", "medals2008", results.getString("TABLE_NAME"));
115		assertFalse(results.next());
116		}
117
118		@Test
119		public void testBadTableNameFails() throws SQLException
120		{
121		Connection conn = DriverManager.getConnection("jdbc:relique:csv:zip:"
122		+ filePath + File.separator + TEST_ZIP_FILENAME_1);
123
124		Statement stmt = conn.createStatement();
125
126		try
127		{
128		stmt.executeQuery("SELECT * FROM abc");
129		fail("Query should fail");
130		}
131		catch (SQLException e)
132		{
133		String message = "" + e;
134		assertTrue(message.startsWith("java.sql.SQLException: " + CsvResources.getString("tableNotFound") + ":"));
	126	Statement stmt = conn.createStatement())
	127	{
	128	try
	129	{
	130	stmt.executeQuery("SELECT * FROM abc");
	131	fail("Query should fail");
	132	}
	133	catch (SQLException e)
	134	{
	135	String message = "" + e;
	136	assertTrue(message.startsWith("java.sql.SQLException: " + CsvResources.getString("tableNotFound") + ":"));
	137	}
135	138	}
136	139	}
137	140
138	141	@Test
139	142	public void testBadZipFileFails() throws SQLException
140	143	{
141		try
142		{
143		DriverManager.getConnection("jdbc:relique:csv:zip:"
144		+ filePath + File.separator + "abc" + TEST_ZIP_FILENAME_1);
	144	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:zip:"
	145	+ filePath + File.separator + "abc" + TEST_ZIP_FILENAME_1))
	146	{
145	147	fail("Connection should fail");
146	148	}
147	149	catch (SQLException e)

159	161	props.put("charset", "ISO-8859-1");
160	162	props.put("fileExtension", ".txt");
161	163
162		Connection conn = DriverManager.getConnection("jdbc:relique:csv:zip:"
	164	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:zip:"
163	165	+ filePath + File.separator + TEST_ZIP_FILENAME_2, props);
164
165		Statement stmt = conn.createStatement();
166
167		ResultSet results = stmt.executeQuery("SELECT * FROM iso8859-1");
168		assertTrue(results.next());
169		assertEquals("ISO8859-1 encoding is wrong", "K\u00D8BENHAVN", results.getString(1));
170		assertTrue(results.next());
171		assertEquals("ISO8859-1 encoding is wrong", "100\u00B0", results.getString(1));
172		assertTrue(results.next());
173		assertEquals("ISO8859-1 encoding is wrong", "\u00A9 Copyright", results.getString(1));
	166	Statement stmt = conn.createStatement();
	167	ResultSet results = stmt.executeQuery("SELECT * FROM iso8859-1"))
	168	{
	169	assertTrue(results.next());
	170	assertEquals("ISO8859-1 encoding is wrong", "K\u00D8BENHAVN", results.getString(1));
	171	assertTrue(results.next());
	172	assertEquals("ISO8859-1 encoding is wrong", "100\u00B0", results.getString(1));
	173	assertTrue(results.next());
	174	assertEquals("ISO8859-1 encoding is wrong", "\u00A9 Copyright", results.getString(1));
	175	}
174	176	}
175	177
176	178	@Test

181	183	props.put("charset", "UTF-8");
182	184	props.put("fileExtension", ".txt");
183	185
184		Connection conn = DriverManager.getConnection("jdbc:relique:csv:zip:"
	186	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:zip:"
185	187	+ filePath + File.separator + TEST_ZIP_FILENAME_2, props);
186
187		Statement stmt = conn.createStatement();
188
189		ResultSet results = stmt.executeQuery("SELECT * FROM utf-8");
190		assertTrue(results.next());
191		assertEquals("UTF-8 encoding is wrong", "K\u00D8BENHAVN", results.getString(1));
192		assertTrue(results.next());
193		assertEquals("UTF-8 encoding is wrong", "100\u00B0", results.getString(1));
194		assertTrue(results.next());
195		assertEquals("UTF-8 encoding is wrong", "\u00A9 Copyright", results.getString(1));
	188	Statement stmt = conn.createStatement();
	189	ResultSet results = stmt.executeQuery("SELECT * FROM utf-8"))
	190	{
	191	assertTrue(results.next());
	192	assertEquals("UTF-8 encoding is wrong", "K\u00D8BENHAVN", results.getString(1));
	193	assertTrue(results.next());
	194	assertEquals("UTF-8 encoding is wrong", "100\u00B0", results.getString(1));
	195	assertTrue(results.next());
	196	assertEquals("UTF-8 encoding is wrong", "\u00A9 Copyright", results.getString(1));
	197	}
196	198	}
197	199
198	200	@Test

203	205	props.put("charset", "UTF-16");
204	206	props.put("fileExtension", ".txt");
205	207
206		Connection conn = DriverManager.getConnection("jdbc:relique:csv:zip:"
	208	try (Connection conn = DriverManager.getConnection("jdbc:relique:csv:zip:"
207	209	+ filePath + File.separator + TEST_ZIP_FILENAME_2, props);
208
209		Statement stmt = conn.createStatement();
210
211		ResultSet results = stmt.executeQuery("SELECT * FROM utf-16");
212		assertTrue(results.next());
213		assertEquals("UTF-16 encoding is wrong", "K\u00D8BENHAVN", results.getString(1));
214		assertTrue(results.next());
215		assertEquals("UTF-16 encoding is wrong", "100\u00B0", results.getString(1));
216		assertTrue(results.next());
217		assertEquals("UTF-16 encoding is wrong", "\u00A9 Copyright", results.getString(1));
	210	Statement stmt = conn.createStatement();
	211	ResultSet results = stmt.executeQuery("SELECT * FROM utf-16"))
	212	{
	213	assertTrue(results.next());
	214	assertEquals("UTF-16 encoding is wrong", "K\u00D8BENHAVN", results.getString(1));
	215	assertTrue(results.next());
	216	assertEquals("UTF-16 encoding is wrong", "100\u00B0", results.getString(1));
	217	assertTrue(results.next());
	218	assertEquals("UTF-16 encoding is wrong", "\u00A9 Copyright", results.getString(1));
	219	}
218	220	}
219	221	}

src/testdata/utf16le_01102018.txt less more

Binary diff not shown

src/testdata/utf16le_04112020.txt less more

Binary diff not shown

-2

src/testdata/yogesh_de.csv less more

0	0	ID,T
1		100,25-OKT-13 01:29:07.613 PM
2		200,06-DEZ-13 11:52:21.342 AM
	1	100,25-OKT-13 13:29:07.613
	2	200,06-DEZ-13 11:52:21.342