import com.almworks.sqlite4java.SQLiteConnection; //导入依赖的package包/类
private CardsManager() throws SQLiteException {
	SQLiteConnection db = new SQLiteConnection(new File(YGOCoreMain.getConfigurator().getDataBasePath()));
	db.open(true);
	SQLiteStatement st = db.prepare("SELECT id, ot, alias, type, level, race, attribute, atk, def FROM datas");
	try {
		while(st.step()) {
			int id = st.columnInt(0);
			Card c = new Card(id, st.columnInt(1));
			c.alias = st.columnInt(2);
			c.setcode = st.columnInt(3);
			int levelinfo = st.columnInt(4);
			c.level = levelinfo & 0xff;
			c.lscale = (levelinfo >> 24) & 0xff;
			c.rscale = (levelinfo >> 16) & 0xff;
			c.race = st.columnInt(6);
			c.attr = st.columnInt(7);
			c.attack = st.columnInt(8);
			c.defense = st.columnInt(9);
			mCards.put(id, c);
		}
	} finally {
		st.dispose();
	}
	db.dispose();
	
}
 

import com.almworks.sqlite4java.SQLiteConnection; //导入依赖的package包/类
public int open(final String path) {

      SQLiteConnection dbConnection = execute("open SQLite connection", new Callable<SQLiteConnection>() {
        @Override
        public SQLiteConnection call() throws Exception {
          SQLiteConnection connection = IN_MEMORY_PATH.equals(path)
              ? new SQLiteConnection()
              : new SQLiteConnection(new File(path));

          connection.open();

          return connection;
        }
      });

      int ptr = pointerCounter.incrementAndGet();
      connectionsMap.put(ptr, dbConnection);
      return ptr;
    }
 

import com.almworks.sqlite4java.SQLiteConnection; //导入依赖的package包/类
public int prepareStatement(final int connectionPtr, final String sql) {
  // TODO: find a way to create collators
  if ("REINDEX LOCALIZED".equals(sql)) {
    return IGNORED_REINDEX_STMT;
  }

  SQLiteStatement stmt = execute("prepare statement", new Callable<SQLiteStatement>() {
    @Override
    public SQLiteStatement call() throws Exception {
      SQLiteConnection connection = getConnection(connectionPtr);
      return connection.prepare(sql);
    }
  });

  int pointer = pointerCounter.incrementAndGet();
  statementsMap.put(pointer, stmt);
  return pointer;
}
 

import com.almworks.sqlite4java.SQLiteConnection; //导入依赖的package包/类
/**
 * Check if the column exists in the table, if yes, check the type, if no
 * create it with the appropriate type.
 * 
 * @param db
 * @param columnsInTable
 *            A Map containing all columns which exists in the table and
 *            their type.
 * @param tablename
 *            The table which should be checked
 * @param columnname
 *            The column in this table which should be checked
 * @param type
 *            The desired type of the column
 * @throws SQLiteException
 * @throws InconsistentTableException
 *             If the column already exists in the table but the type is
 *             wrong.
 */
private static void checkCreateColumn(SQLiteConnection db, Map<String, String> columnsInTable, String tablename, String columnname, String type)
		throws SQLiteException, InconsistentTableException
{
	String columnnameLower = columnname.toLowerCase();
	String typeUpper = type.toUpperCase();

	if (columnsInTable.containsKey(columnnameLower))
	{
		String actualType = columnsInTable.get(columnnameLower);
		if (!actualType.equals(typeUpper))
		{
			throw new InconsistentTableException("Column " + tablename + "." + columnname + " should be " + typeUpper + " but is " + actualType);
		}
	} else
	{
		LOGGER.debug("Create SQL %s", "ALTER TABLE " + tablename + " ADD COLUMN " + columnname + " " + typeUpper + " DEFAULT NULL;");
		db.exec("ALTER TABLE " + tablename + " ADD COLUMN " + columnname + " " + typeUpper + " DEFAULT NULL;");
	}
}
 

import com.almworks.sqlite4java.SQLiteConnection; //导入依赖的package包/类
public static SQLiteCursor buildSQLiteCursor(SQLiteConnection conn, String sql, Object[] bindArgs)
        throws SQLiteException {
    SQLiteStatement stmt = null;
    try {
        stmt = bindArguments(conn.prepare(sql), bindArgs);
        List<String> columnNames = null;
        List<Tuple> resultSet = new ArrayList<Tuple>();
        while (!stmt.hasStepped() || stmt.hasRow()) {
            if (!stmt.step()) {
                break;
            }
            if (columnNames == null) {
                columnNames = getColumnNames(stmt);
            }

            Tuple t = getDataRow(stmt);
            logger.finest("Tuple: "+ t.toString());
            resultSet.add(t);
        }
        return new SQLiteCursor(columnNames, resultSet);
    } finally {
        SQLiteWrapperUtils.disposeQuietly(stmt);
    }
}
 

import com.almworks.sqlite4java.SQLiteConnection; //导入依赖的package包/类
public SQLiteQuery(SQLiteConnection connection, String sqlQuery, boolean cacheStmt)
		throws SQLiteException {
	super();

	this.queryString = sqlQuery;
	this.stmt = connection.prepare(sqlQuery, cacheStmt);

	HashMap<String, Integer> colIdxByColName = new HashMap<String, Integer>();

	int nbCols = stmt.columnCount();
	for (int colIdx = 0; colIdx < nbCols; colIdx++) {
		String colName = stmt.getColumnName(colIdx);
		colIdxByColName.put(colName, colIdx);
	}

	this.resultDesc = new SQLiteResultDescriptor(colIdxByColName);
}
 

import com.almworks.sqlite4java.SQLiteConnection; //导入依赖的package包/类
/**
 * Lazy loading of the acquisition mode, parameter
 *
 * @return
 * @throws SQLiteException
 */
protected AcquisitionMode getAcquisitionMode(SQLiteConnection connection) throws SQLiteException {

	if (this.acquisitionMode == null) {
		/*
		 * final String sqlString = "SELECT param_tree FROM run"; final String runParamTree = new
		 * SQLiteQuery(connection, sqlString).extractSingleString(); final ParamTree runTree =
		 * ParamTreeParser.parseParamTree(runParamTree);
		 */

		List<Run> runs = this.getRuns();
		Run run0 = runs.get(0);
		final ParamTree runTree = run0.getParamTree(connection);

		try {
			final CVParam cvParam = runTree.getCVParam(CVEntry.ACQUISITION_PARAMETER);
			final String value = cvParam.getValue();
			this.acquisitionMode = AcquisitionMode.getAcquisitionMode(value);
		} catch (Exception e) {
			this.acquisitionMode = AcquisitionMode.UNKNOWN;
		}
	}

	return this.acquisitionMode;
}
 

import com.almworks.sqlite4java.SQLiteConnection; //导入依赖的package包/类
protected Peak[] getMsnXic(
	double parentMz,
	double fragmentMz,
	double fragmentMzTolInDa,
	float minRt,
	float maxRt,
	XicMethod method,
	SQLiteConnection connection) throws SQLiteException,
			StreamCorruptedException {

	final double minFragMz = fragmentMz - fragmentMzTolInDa;
	final double maxFragMz = fragmentMz + fragmentMzTolInDa;
	final float minRtForRtree = minRt >= 0 ? minRt : 0;
	final float maxRtForRtree = maxRt > 0 ? maxRt : MzDbReaderQueries.getLastTime(connection);

	SpectrumSlice[] spectrumSlices = this.getMsnSpectrumSlices(parentMz, minFragMz, maxFragMz, minRtForRtree, maxRtForRtree, connection);

	final double fragMzTolPPM = MsUtils.DaToPPM(fragmentMz, fragmentMzTolInDa);
	return this._spectrumSlicesToXIC(spectrumSlices, fragmentMz, fragMzTolPPM, method);
}
 

import com.almworks.sqlite4java.SQLiteConnection; //导入依赖的package包/类
/**
    * For unit tests only
    */
public void deleteAllIAs() {
	SQLiteConnection connection = null;
	SQLiteStatement statement = null;
	try {
		connection = getSQLiteConnection();
		connection.exec("delete from dhcplease");
	}
	catch (SQLiteException ex) {
		log.error("deleteAllIAs failed", ex);
		throw new RuntimeException(ex);
	}
	finally {
		closeStatement(statement);
		closeConnection(connection);
	}
}
 

import com.almworks.sqlite4java.SQLiteConnection; //导入依赖的package包/类
/**
 * Gets the bounding box ms level.
 *
 * @param bbId
 *            the bb id
 * @return the bounding box ms level
 * @throws SQLiteException
 *             the sQ lite exception
 */
public static int getBoundingBoxMsLevel(int bbId, SQLiteConnection connection) throws SQLiteException {

	// FIXME: check that the mzDB file has the bounding_box_msn_rtree table
	String sqlString1 = "SELECT run_slice_id FROM bounding_box WHERE id = ?";
	int runSliceId = new SQLiteQuery(connection, sqlString1).bind(1, bbId).extractSingleInt();

	String sqlString2 = "SELECT ms_level FROM run_slice WHERE run_slice.id = ?";
	return new SQLiteQuery(connection, sqlString2).bind(1, runSliceId).extractSingleInt();

	/*
	 * String sqlString =
	 * "SELECT min_ms_level FROM bounding_box_msn_rtree WHERE bounding_box_msn_rtree.id = ?"; return new
	 * SQLiteQuery(connection, sqlString).bind(1, bbId).extractSingleInt();
	 */
}
 

import com.almworks.sqlite4java.SQLiteConnection; //导入依赖的package包/类
protected static boolean canOpen(Configuration conf,
        String input,
        ProviderProperties providerProperties) throws IOException
{
  MbVectorTilesSettings dbSettings = parseResourceName(input, conf, providerProperties);
  SQLiteConnection conn = null;
  try {
    conn = getDbConnection(dbSettings, conf);
    return true;
  }
  catch(IOException e) {
    log.info("Unable to open MB vector tiles database: " + dbSettings.getFilename(), e);
  }
  finally {
    if (conn != null) {
      conn.dispose();
    }
  }
  return false;
}
 

import com.almworks.sqlite4java.SQLiteConnection; //导入依赖的package包/类
/**
 * Gets the run slice ids for mz range.
 *
 * @param minMz
 *            the min mz
 * @param maxMz
 *            the max mz
 * @param msLevel
 *            the ms level
 * @param connection
 *            the connection
 * @return the run slice ids for mz range
 * @throws SQLiteException
 *             the sQ lite exception
 */
protected int[] getRunSliceIdsForMzRange(double minMz, double maxMz, int msLevel, SQLiteConnection connection) throws SQLiteException {

	RunSliceHeader firstRunSlice = this.getRunSliceForMz(minMz, msLevel, connection);
	RunSliceHeader lastRunSlice = this.getRunSliceForMz(maxMz, msLevel, connection);
	double mzHeight = (msLevel == 1) ? this.getMzDbReader().getBBSizes().BB_MZ_HEIGHT_MS1 : this.getMzDbReader().getBBSizes().BB_MZ_HEIGHT_MSn;

	int bufferLength = 1 + (int) ((maxMz - minMz) / mzHeight);

	String queryStr = "SELECT id FROM run_slice WHERE ms_level = ? AND begin_mz >= ? AND end_mz <= ?";

	return new SQLiteQuery(connection, queryStr)
			.bind(1, msLevel)
			.bind(2, firstRunSlice.getBeginMz())
			.bind(3, lastRunSlice.getEndMz())
			.extractInts(bufferLength);
}
 

import com.almworks.sqlite4java.SQLiteConnection; //导入依赖的package包/类
public LcMsRunSliceIterator(
	AbstractMzDbReader mzDbReader,
	SQLiteConnection connection,
	double minRunSliceMz,
	double maxRunSliceMz
) throws SQLiteException, StreamCorruptedException {		
	// Set msLevel to 1
	super(
		mzDbReader.getRunSliceHeaderReader(),
		mzDbReader.getSpectrumHeaderReader(),
		mzDbReader.getDataEncodingReader(),
		connection,
		runSlicesSubsetSqlQuery,
		1,
		createRunSlicesSubsetStatementBinder(minRunSliceMz,maxRunSliceMz)
	);
}
 

import com.almworks.sqlite4java.SQLiteConnection; //导入依赖的package包/类
public BoundingBoxIterator(
	AbstractSpectrumHeaderReader spectrumHeaderReader,
	AbstractDataEncodingReader dataEncodingReader,
	SQLiteConnection connection,
	SQLiteStatement stmt,
	int msLevel
) throws SQLiteException, StreamCorruptedException {
	super(stmt);
	
	if( msLevel == 1 ) this.spectrumHeaderById = spectrumHeaderReader.getMs1SpectrumHeaderById(connection);
	else if( msLevel == 2 ) this.spectrumHeaderById = spectrumHeaderReader.getMs2SpectrumHeaderById(connection);
	else if( msLevel == 3 ) this.spectrumHeaderById = spectrumHeaderReader.getMs3SpectrumHeaderById(connection);
	else throw new IllegalArgumentException("unsupported MS level: " + msLevel);
	
	this.dataEncodingBySpectrumId = dataEncodingReader.getDataEncodingBySpectrumId(connection);
}
 

import com.almworks.sqlite4java.SQLiteConnection; //导入依赖的package包/类
public MsSpectrumRangeIteratorImpl(AbstractMzDbReader mzDbReader, SQLiteConnection connection, final int msLevel) throws SQLiteException,
		StreamCorruptedException {
	//super(mzDbReader, sqlQuery, msLevel, rethrowConsumer( (stmt) -> stmt.bind(1, msLevel) ) ); // Bind msLevel
	super(
		mzDbReader.getSpectrumHeaderReader(),
		mzDbReader.getDataEncodingReader(),
		connection,
		sqlQuery,
		msLevel,
		new ISQLiteStatementConsumer() {
			public void accept(SQLiteStatement stmt) throws SQLiteException {
				stmt.bind(1, msLevel); // Bind msLevel
			}
		}
	);
	
	this.initSpectrumSliceBuffer();
}
 

import com.almworks.sqlite4java.SQLiteConnection; //导入依赖的package包/类
public SpectrumIterator(AbstractMzDbReader mzDbReader, SQLiteConnection connection, final int msLevel) throws SQLiteException, StreamCorruptedException {
	//super(inst, sqlQuery, msLevel, rethrowConsumer( (stmt) -> stmt.bind(1, msLevel) ) ); // Bind msLevel
	super(
		mzDbReader.getSpectrumHeaderReader(),
		mzDbReader.getDataEncodingReader(),
		connection,
		singleMsLevelSqlQuery,
		msLevel,
		new ISQLiteStatementConsumer() {
			public void accept(SQLiteStatement stmt) throws SQLiteException {
				stmt.bind(1, msLevel); // Bind msLevel
			}
		}
	);
	
	this.usePriorityQueue = false;
	this.priorityQueue = null;

	this.initSpectrumSliceBuffer();
}
 

import com.almworks.sqlite4java.SQLiteConnection; //导入依赖的package包/类
protected List<DhcpLease> findExpiredLeases(final byte iatype) {
	SQLiteConnection connection = null;
	SQLiteStatement statement = null;
	try {
		connection = getSQLiteConnection();
		statement = connection.prepare(
	                "select * from dhcplease" +
	                " where iatype = ?" +
	                " and state != " + IaAddress.STATIC +
	                " and validendtime < ? order by validendtime");
		statement.bind(1, iatype);
		statement.bind(2, new Date().getTime());
		
		return mapLeases(statement);
	}
	catch (SQLiteException ex) {
		log.error("findExpiredLeases failed", ex);
		throw new RuntimeException(ex);
	}
	finally {
		closeStatement(statement);
		closeConnection(connection);
	}
}
 

import com.almworks.sqlite4java.SQLiteConnection; //导入依赖的package包/类
/**
 * Delete dhcp lease.
 *
 * @param lease the lease
 */
protected void deleteDhcpLease(final DhcpLease lease)
{
	SQLiteConnection connection = null;
	SQLiteStatement statement = null;
	try {
		connection = getSQLiteConnection();
		statement = connection.prepare("delete from dhcplease" +
				 	" where ipaddress=?");
		statement.bind(1, lease.getIpAddress().getAddress());
		
		while (statement.step()) {
			log.debug("deleteDhcpLease: step=true");
		}
	}
	catch (SQLiteException ex) {
		log.error("deleteDhcpLease failed", ex);
		throw new RuntimeException(ex);
	}
	finally {
		closeStatement(statement);
		closeConnection(connection);
	}
}
 

import com.almworks.sqlite4java.SQLiteConnection; //导入依赖的package包/类
/**
 * Does the job explained above for one BenchmarkDriver (for the dependent
 * variables).
 * 
 * @param db
 *            SQLite database which stores the tables
 * @param benchVars
 *            A EMF-Eclass describing the independent variables for the
 *            specific benchmark driver specific benchmark driver
 * @throws SQLiteException
 */
private void setupDependentTables(SQLiteConnection db, DependentVariables benchVars) throws SQLiteException
{
	String prefix = benchVars.getBenchmarkPrefix();

	// Construct queries for insertion of dependent variables.
	StringBuilder dvSql = new StringBuilder("INSERT INTO " + prefix + "DependentVars (runId, ");
	dvSql.append("benchPrefix");
	dvSql.append(") VALUES (?, ?");
	dvSql.append(");");

	// Rembemeber the statements for later use when values should be
	// inserted
	dvStmnts.put(prefix + "_first", db.prepare(dvSql.toString()));

	LOGGER.debug("SQL for prefix %s=%s", prefix + "_first", dvSql.toString());

	dvSql = new StringBuilder("INSERT INTO " + prefix + "DependentVarsValues (dvId, ");
	dvSql.append("operation, opMetric, opValue, opTimestamp, opType");
	dvSql.append(") VALUES (?, ?, ?, ?, ?, ?");
	dvSql.append(");");

	dvStmnts.put(prefix + "_second", db.prepare(dvSql.toString()));

	LOGGER.debug("SQL for prefix %s=%s", prefix + "_second", dvSql.toString());
}
 

import com.almworks.sqlite4java.SQLiteConnection; //导入依赖的package包/类
public SQLiteConnection getConnection(final int pointer) {
  SQLiteConnection connection = connectionsMap.get(pointer);
  if (connection == null) {
    throw new IllegalStateException("Illegal connection pointer " + pointer
        + ". Current pointers for thread " + Thread.currentThread() + " " + connectionsMap.keySet());
  }
  return connection;
}