Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Copyright (C) 2014 Zach Melamed
   * 
   * Latest version available online at https://github.com/zach-m/tectonica-commons
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
  * http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 
 package com.tectonica.kvs.impl;
 
 import java.util.List;
 import java.util.Map;
 
 
 public class SqliteKeyValueStore<V extends Serializableextends AbstractKeyValueStore<String, V>
 {
 	private final Class<V> valueClass;
 	private final String table;
 	private final Serializer<V> serializer;
 	private final List<SqliteIndexImpl<?>> indexes;
 	private final List<StringindexeCols;
 	private final JDBC jdbc;

creates a new key-value store backed by Sqlite

Parameters:
keyMapper this optional parameter is suitable in situations where the key of an entry can be inferred from its value directly (as opposed to when the key and value are stored separately). when provided, several convenience methods become applicable
 
 	public SqliteKeyValueStore(Class<V> valueClassString connStrKeyMapper<String, V> keyMapper)
 	{
 		super(keyMapper);
 		this. = valueClass;
 		this. = valueClass.getSimpleName();
 		this. = new JavaSerializer<V>();
 		this. = new ArrayList<>();
 		this. = new ArrayList<>();
 		this. = SqliteUtil.connect(connStr);
 	}
 
 	protected Cache<String, V> createCache()
 	{
 		return new InMemCache();
 	}

GETTERS /
 
 
 	protected V dbGet(final String key)
 	{
 		return .execute(new ConnListener<V>()
 		{
 			public V onConnection(Connection connthrows SQLException
 			{
 				stmt.setString(1, key);
 				ResultSet rs = stmt.executeQuery();
 				byte[] bytes = (rs.next()) ? rs.getBytes(1) : null;
			}
		});
	}
	{
		{
			{
			}
		});
	}
	protected Iterator<KeyValue<String, V>> dbOrderedIterator(final Collection<Stringkeys)
	{
		{
			{
				int i = 0;
				for (String key : keys)
					stmt.setString(++ikey);
				// fetch all results into memory
				Map<Stringbyte[]> prefetch = new HashMap<>();
				ResultSet rs = stmt.executeQuery();
				while (rs.next())
					prefetch.put(rs.getString(1), rs.getBytes(2));
				// sort by the same order of the keys passed by the user
				List<KeyValue<Stringbyte[]>> ordered = orderByKeys(prefetchkeys);
			}
		});
	}
	{
		{
			{
			}
		});
	}
	public Iterator<V> valueIterator()
	{
		{
			{
			}
		});
	}
	public boolean containsKey(final String key)
	{
		{
			{
				stmt.setString(1, key);
				return stmt.executeQuery().next();
			}
		});
	}

SETTERS (UTILS) /
	protected Modifier<String, V> getModifier(final String keyModificationType purpose)
	{
		return new Modifier<String, V>()
		{
			public V getModifiableValue()
			{
value =  ? .get(key) : null;
				if (value != null// if we get a (local, in-memory) copy from the cache, we have to return a duplicate
					return .copyOf(value);
				return dbGet(key);
			}
			public void dbPut(final V value)
			{
				int updated = upsertRow(keyvaluefalse);
				if (updated != 1)
					throw new RuntimeException("Unexpected dbUpdate() count: " + updated);
			}
		};
	}
	{
		public Lock valueOf(final String key)
		{
			return new ReentrantLock()
			{
				private static final long serialVersionUID = 1L;
				public void unlock()
				{
					super.unlock();
				}
			};
		}
	});
	{
		try
		{
			return .acquire(key);
		}
		{
			throw new RuntimeException(e);
		}
	}

SETTERS /
	protected void dbInsert(final String keyfinal V value)
	{
		int inserted = upsertRow(keyvaluetrue);
		if (inserted != 1)
			throw new RuntimeException("Unexpected dbInsert() count: " + inserted);
	}

DELETERS /
	protected boolean dbDelete(final String key)
	{
		int deleted = .execute(new ConnListener<Integer>()
		{
			{
				stmt.setString(1, key);
				return stmt.executeUpdate();
			}
		});
		return (deleted != 0);
	}
	protected int dbDeleteAll()
	{
		{
			{
			}
		});
	}

INDEXES /
	public <F> Index<String, V, F> createIndex(final String indexNameIndexMapper<V, F> mapFunc)
	{
		{
			public Void onConnection(Connection connthrows SQLException
			{
				try
				{
				}
				catch (Exception e)
				{
					// probably 'duplicate column name'
				}
				return null;
			}
		});
		SqliteIndexImpl<F> index = new SqliteIndexImpl<>(mapFuncindexName);
		.add(index);
		return index;
	}
	private class SqliteIndexImpl<F> extends AbstractIndex<String, V, F>
	{
		public SqliteIndexImpl(IndexMapper<V, F> mapFuncString name)
		{
			super(mapFuncname);
		}
		public Iterator<KeyValue<String, V>> iteratorOf(final F f)
		{
		}
		{
		}
		public Iterator<V> valueIteratorOf(F f)
		{
		}
		private ExecutionContext selectByIndex(final F f)
		{
			{
				{
					stmt.setString(1, f.toString());
					return stmt.executeQuery();
				}
			});
			return ctx;
		}
		private String getIndexedFieldOf(V value)
		{
idx = .getIndexedFieldOf(value);
			return (idx == null) ? null : idx.toString();
		}
	}

SQL QUERIES /
	{
		return String.format("CREATE TABLE IF NOT EXISTS %s (K VARCHAR2 PRIMARY KEY, V BLOB)");
	}
	{
		return String.format("SELECT V FROM %s WHERE K=?");
	}
	private String sqlSelectAll()
	{
		return String.format("SELECT K,V FROM %s");
	}
	{
		return String.format("SELECT K,V FROM %s WHERE K IN (%s)", STR.implode("?"","keys.size()));
	}
	{
		return String.format("SELECT 1 FROM %s WHERE K=?");
	}
	private String sqlUpsert(boolean strictInsert)
	{
		String statement = strictInsert ? "INSERT" : "REPLACE";
		String pfx = (.size() > 0) ? "," : "";
		String cols = pfx + STR.implode(","false);
		String qm = pfx + STR.implode("?"",".size());
		return String.format("%s INTO %s (K,V %s) VALUES (?,? %s)"statementcolsqm);
	}
	{
		return String.format("DELETE FROM %s WHERE K=?");
	}
	private String sqlDeleteAll()
	{
		return String.format("DELETE FROM %s"); // not TRUNCATE, as we want the deleted-count
	}
	private String sqlAddColumn(String indexName)
	{
		// TODO: we save the indexes values as strings instead of their possibly other native data type, can be improved
		return String.format("ALTER TABLE %s ADD COLUMN %s VARCHAR2"colOfIndex(indexName));
	}
	private String sqlCreateIndex(String indexName)
	{
		return String.format("CREATE INDEX IF NOT EXISTS IDX_%s ON %s (%s)"indexNamecolOfIndex(indexName));
	}
	private String sqlSelectByIndex(String indexName)
	{
		return String.format("SELECT K,V FROM %s WHERE %s=?"colOfIndex(indexName));
	}
	private String colOfIndex(String indexName)
	{
		return "_i_" + indexName;
	}

DATABASE UTILS /
	private void createTable()
	{
		{
			public Void onConnection(Connection connthrows SQLException
			{
				return null;
			}
		});
	}
	{
		final ResultSetIterator iter = ctx.iterator();
		return new Iterator<KeyValue<String, V>>()
		{
			public boolean hasNext()
			{
				return iter.hasNext();
			}
			public KeyValue<String, V> next()
			{
				final ResultSet rs = iter.next();
				return new KeyValue<String, V>()
				{
					public String getKey()
					{
						return rsGetKey(rs);
					}
					public V getValue()
					{
						return rsGetValue(rs);
					}
				};
			}
			public void remove()
			{
			}
		};
	}
	{
		final ResultSetIterator iter = ctx.iterator();
		return new Iterator<String>()
		{
			public boolean hasNext()
			{
				return iter.hasNext();
			}
			public String next()
			{
				return rsGetKey(iter.next());
			}
			public void remove()
			{
			}
		};
	}
	{
		final ResultSetIterator iter = ctx.iterator();
		return new Iterator<V>()
		{
			public boolean hasNext()
			{
				return iter.hasNext();
			}
			public V next()
			{
				return rsGetValue(iter.next());
			}
			public void remove()
			{
			}
		};
	}
	private String rsGetKey(ResultSet rs)
	{
		try
		{
			return rs.getString(1);
		}
		catch (SQLException e)
		{
			throw new RuntimeException(e);
		}
	}
	private V rsGetValue(ResultSet rs)
	{
		try
		{
		}
		catch (SQLException e)
		{
			throw new RuntimeException(e);
		}
	}
	private Iterator<KeyValue<String, V>> entryIteratorOfBytesIter(final Iterator<KeyValue<Stringbyte[]>> iter)
	{
		return new Iterator<KeyValue<String, V>>()
		{
			public boolean hasNext()
			{
				return iter.hasNext();
			}
			public KeyValue<String, V> next()
			{
				final KeyValue<Stringbyte[]> rkv = iter.next();
				return new KeyValue<String, V>()
				{
					public String getKey()
					{
						return rkv.getKey();
					}
					public V getValue()
					{
					}
				};
			}
			public void remove()
			{
			}
		};
	}
	private Integer upsertRow(final String keyfinal V valuefinal boolean strictInsert)
	{
		{
			{
				PreparedStatement stmt = conn.prepareStatement(sqlUpsert(strictInsert));
				stmt.setString(1, key);
				stmt.setBytes(2, .objToBytes(value));
				for (int i = 0; i < .size(); i++)
				{
					SqliteIndexImpl<?> index = .get(i);
					String field = (value == null) ? null : index.getIndexedFieldOf(value);
					stmt.setString(3 + ifield);
				}
				return stmt.executeUpdate();
			}
		});
	}

SERIALIZATION /
	public static interface Serializer<V>
	{
bytesToObj(byte[] bytesClass<V> clz);
		byte[] objToBytes(V obj);
copyOf(V obj);
	}
	private static final class JavaSerializer<V> implements Serializer<V>
	{
		public V bytesToObj(byte[] bytesClass<V> clz)
		{
			return SerializeUtil.bytesToObj(bytesclz);
		}
		public byte[] objToBytes(V obj)
		{
			return SerializeUtil.objToBytes(obj);
		}
		public V copyOf(V obj)
		{
			return SerializeUtil.copyOf(obj);
		}
	}

CACHE IMPLEMENTATION /
	private class InMemCache implements Cache<String, V>
	{
		// based on Guava cache
		private com.google.common.cache.Cache<String, V> cache = com.google.common.cache.CacheBuilder.newBuilder().maximumSize(1000)
		public V get(String key)
		{
			return .getIfPresent(key);
		}
		public Map<String, V> get(Collection<Stringkeys)
		{
			return .getAllPresent(keys);
		}
		public void put(String key, V value)
		{
			.put(keyvalue);
		}
		public void put(Map<String, V> values)
		{
			.putAll(values);
		}
		public void delete(String key)
		{
		}
		public void deleteAll()
		{
		}
	};
New to GrepCode? Check out our FAQ X