Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   This is free and unencumbered software released into the public domain.
  
   Anyone is free to copy, modify, publish, use, compile, sell, or
   distribute this software, either in source code form or as a compiled
   binary, for any purpose, commercial or non-commercial, and by any
   means.
  
   In jurisdictions that recognize copyright laws, the author or authors
  of this software dedicate any and all copyright interest in the
  software to the public domain. We make this dedication for the benefit
  of the public at large and to the detriment of our heirs and
  successors. We intend this dedication to be an overt act of
  relinquishment in perpetuity of all present and future rights to this
  software under copyright law.
 
  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
  IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
  OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  OTHER DEALINGS IN THE SOFTWARE.
  */
 package base;
 
 import java.sql.Array;
 import java.sql.Blob;
 import java.sql.Clob;
 import java.sql.NClob;
 import java.util.Map;
 
A datasource that holds a single database connection. Serialises requests to an SQLite database and avoids the SQLite "locked" exception.
 
 public class SingleConnectionDataSource implements DataSource {
 
 	private SC c = null;
 
 		this. = new SC(c);
 	}
 
 	public PrintWriter getLogWriter() throws SQLException {
 		return null;
 	}
 
 	public int getLoginTimeout() throws SQLException {
 		return 0;
 	}
 
 	public void setLogWriter(PrintWriter arg0throws SQLException {
 	}
 
 	public void setLoginTimeout(int arg0throws SQLException {
 	}
 
 	public boolean isWrapperFor(Class<?> arg0throws SQLException {
 		return false;
 	}
 
 	public <T> T unwrap(Class<T> arg0throws SQLException {
 		return null;
 	}
 
 	public Connection getConnection() throws SQLException {
 		try {
 			.lock();
 			.setAutoCommit(false);
 		} catch (InterruptedException e) {
 			throw new SQLException(e);
		}
		return ;
	}
	public Connection getConnection(String arg0String arg1throws SQLException {
		return getConnection();
	}
		return null;
	}

Wrapper around a database connection prevents closing of a connection. lock() is invoked prior to this connection being passed out, and unlock() is automatically called when close() is requested.
	public class SC implements Connection {
		private Connection c;
		private final Lock lock = new ReentrantLock();
		public SC(Connection c) {
			this. = c;
		}
		public void lock() throws InterruptedException {
		}
		public void releaseLock() {
		}
		public boolean isWrapperFor(Class<?> ifacethrows SQLException {
			return false;
		}
		public <T> T unwrap(Class<T> ifacethrows SQLException {
			return null;
		}
		public void clearWarnings() throws SQLException {
		}
		public void close() throws SQLException {
		}
		public void commit() throws SQLException {
		}
		public Array createArrayOf(String typeNameObject[] elementsthrows SQLException {
			return .createArrayOf(typeNameelements);
		}
		public Blob createBlob() throws SQLException {
			return .createBlob();
		}
		public Clob createClob() throws SQLException {
			return .createClob();
		}
		public NClob createNClob() throws SQLException {
			return null;
		}
		public SQLXML createSQLXML() throws SQLException {
			return .createSQLXML();
		}
		public Statement createStatement() throws SQLException {
			return .createStatement();
		}
		public Statement createStatement(int resultSetTypeint resultSetConcurrencythrows SQLException {
			return .createStatement(resultSetTyperesultSetConcurrency);
		}
		public Statement createStatement(int resultSetType,
				int resultSetConcurrencyint resultSetHoldability)
				throws SQLException {
			return .createStatement(resultSetTyperesultSetConcurrencyresultSetHoldability);
		}
		public Struct createStruct(String typeNameObject[] attributes)
				throws SQLException {
			return .createStruct(typeNameattributes);
		}
		public boolean getAutoCommit() throws SQLException {
			return .getAutoCommit();
		}
		public String getCatalog() throws SQLException {
			return .getCatalog();
		}
		public Properties getClientInfo() throws SQLException {
			return .getClientInfo();
		}
		public String getClientInfo(String namethrows SQLException {
			return .getClientInfo(name);
		}
		public int getHoldability() throws SQLException {
			return .getHoldability();
		}
			return .getMetaData();
		}
		public int getTransactionIsolation() throws SQLException {
		}
		public Map<StringClass<?>> getTypeMap() throws SQLException {
			return .getTypeMap();
		}
		public SQLWarning getWarnings() throws SQLException {
			return .getWarnings();
		}
		public boolean isClosed() throws SQLException {
			return .isClosed();
		}
		public boolean isReadOnly() throws SQLException {
			return .isReadOnly();
		}
		public boolean isValid(int timeoutthrows SQLException {
			return .isValid(timeout);
		}
		public String nativeSQL(String sqlthrows SQLException {
			return .nativeSQL(sql);
		}
			return .prepareCall(sql);
		}
		public CallableStatement prepareCall(String sqlint resultSetTypeint resultSetConcurrencythrows SQLException {
			return .prepareCall(sqlresultSetTyperesultSetConcurrency);
		}
		public CallableStatement prepareCall(String sqlint resultSetTypeint resultSetConcurrencyint resultSetHoldabilitythrows SQLException {
			return .prepareCall(sql);
		}
			return .prepareStatement(sql);
		}
				int autoGeneratedKeysthrows SQLException {
			return .prepareStatement(sqlautoGeneratedKeys);
		}
				int[] columnIndexesthrows SQLException {
			return .prepareStatement(sqlcolumnIndexes);
		}
				String[] columnNamesthrows SQLException {
			return .prepareStatement(sqlcolumnNames);
		}
				int resultSetTypeint resultSetConcurrency)
				throws SQLException {
			return .prepareStatement(sqlresultSetTyperesultSetConcurrency);
		}
				int resultSetTypeint resultSetConcurrency,
				int resultSetHoldabilitythrows SQLException {
			return .prepareStatement(sqlresultSetTyperesultSetConcurrencyresultSetHoldability);
		}
		public void releaseSavepoint(Savepoint savepointthrows SQLException {
			.releaseSavepoint(savepoint);
		}
		public void rollback() throws SQLException {
		}
		public void rollback(Savepoint savepointthrows SQLException {
			.rollback(savepoint);
		}
		public void setAutoCommit(boolean autoCommitthrows SQLException {
			.setAutoCommit(autoCommit);
		}
		public void setCatalog(String catalogthrows SQLException {
			.setCatalog(catalog);
		}
		public void setClientInfo(Properties propertiesthrows SQLClientInfoException {
			.setClientInfo(properties);
		}
		public void setClientInfo(String nameString valuethrows SQLClientInfoException {
			.setClientInfo(namevalue);
		}
		public void setHoldability(int holdabilitythrows SQLException {
			.setHoldability(holdability);
		}
		public void setReadOnly(boolean readOnlythrows SQLException {
			throw new IllegalStateException("read only not allowed");
		}
		public Savepoint setSavepoint() throws SQLException {
			return .setSavepoint();
		}
		public Savepoint setSavepoint(String namethrows SQLException {
			return .setSavepoint(name);
		}
		public void setTransactionIsolation(int levelthrows SQLException {
		}
		public void setTypeMap(Map<StringClass<?>> mapthrows SQLException {
		}
		public void setSchema(String schemathrows SQLException {
			.setSchema(schema);
		}
		public String getSchema() throws SQLException {
			return .getSchema();
		}
		public void abort(Executor executorthrows SQLException {
			.abort(executor);
		}
		public void setNetworkTimeout(Executor executorint millisecondsthrows SQLException {
			.setNetworkTimeout(executormilliseconds);
		}
		public int getNetworkTimeout() throws SQLException {
		}
	}
New to GrepCode? Check out our FAQ X