import com.querydsl.sql.Configuration; //导入依赖的package包/类
private void removeAllUsersFromScheme(final long schemeId, final Connection connection,
    final Configuration configuration) {

  final int batchSize = 100;
  QUserWorkScheme qUserWorkScheme = QUserWorkScheme.userWorkScheme;

  SQLQuery<Long> sqlQuery = new SQLQuery<Long>(connection, configuration)
      .select(qUserWorkScheme.dateRangeId).from(qUserWorkScheme)
      .where(qUserWorkScheme.workSchemeId.eq(schemeId)).limit(batchSize);

  List<Long> dateRangeIds = sqlQuery.fetch();
  DateRangeUtil dateRangeUtil = new DateRangeUtil(connection, configuration);

  while (!dateRangeIds.isEmpty()) {
    new SQLDeleteClause(connection, configuration, qUserWorkScheme)
        .where(qUserWorkScheme.dateRangeId.in(dateRangeIds)).execute();

    dateRangeUtil.removeDateRange(dateRangeIds.toArray(new Long[dateRangeIds.size()]));

    dateRangeIds = sqlQuery.fetch();
  }

}
 

import com.querydsl.sql.Configuration; //导入依赖的package包/类
private void processDateRange(final Date startDate, final Date endDateExcluded,
    final Set<Date> insertedDates, final List<Date> dateBatch, final int batchSize,
    final Connection connection, final Configuration configuration) {

  for (Date dateCursor = startDate; dateCursor.before(endDateExcluded); dateCursor =
      DateUtil.addDays(dateCursor, 1)) {

    if (!insertedDates.contains(dateCursor)) {
      insertedDates.add(dateCursor);
      dateBatch.add(dateCursor);
      if (dateBatch.size() == batchSize) {
        flushDateBatch(dateBatch, connection, configuration);
      }
    }
  }
}
 

import com.querydsl.sql.Configuration; //导入依赖的package包/类
private Object synchronizeDateSequenceIfNecessary(final Connection connection,
    final Configuration configuration) {

  QDateSequence qDateSequence = QDateSequence.dateSequence;
  long dateSequenceCount = new SQLQuery<>(connection, configuration)
      .select(Expressions.ONE.count()).from(qDateSequence).fetchOne();

  if (dateSequenceCount == 0) {
    QDateRange qDateRange = QDateRange.dateRange;
    long dateRangeCount = new SQLQuery<>(connection, configuration)
        .select(Expressions.ONE.count()).from(qDateRange).fetchOne();
    if (dateRangeCount != 0) {
      fillDateSequenceFromDateRanges(connection, configuration, dateRangeCount);
    }
  }
  return null;
}
 

import com.querydsl.sql.Configuration; //导入依赖的package包/类
private void removeAllUsersFromScheme(final long schemeId, final Connection connection,
    final Configuration configuration) {

  final int batchSize = 100;
  QUserHolidayScheme qUserHolidayScheme = QUserHolidayScheme.userHolidayScheme;

  SQLQuery<Long> sqlQuery = new SQLQuery<Long>(connection, configuration)
      .select(qUserHolidayScheme.dateRangeId).from(qUserHolidayScheme)
      .where(qUserHolidayScheme.holidaySchemeId.eq(schemeId)).limit(batchSize);

  List<Long> dateRangeIds = sqlQuery.fetch();

  while (!dateRangeIds.isEmpty()) {
    new SQLDeleteClause(connection, configuration, qUserHolidayScheme)
        .where(qUserHolidayScheme.dateRangeId.in(dateRangeIds)).execute();

    new DateRangeUtil(connection, configuration)
        .removeDateRange(dateRangeIds.toArray(new Long[dateRangeIds.size()]));

    dateRangeIds = sqlQuery.fetch();
  }

}
 

import com.querydsl.sql.Configuration; //导入依赖的package包/类
/**
 * Loads the database used for storing locations of mp3 files contained in the library for later playback
 * If needed creates a new database based on the available tags of the mp3agic library
 *
 * @param databaseLocation Location of the sqlite database
 * @throws SQLException should theoretically not get thrown, if thrown something in generating the tables through SQL went wrong
 * @throws IOException  gets thrown in case the needed folder structure for the database can't be created
 */
public LibraryDatabase(File databaseLocation) throws SQLException, IOException {
    if(!databaseLocation.isAbsolute()) databaseLocation = databaseLocation.getAbsoluteFile();
    if (!databaseLocation.exists()) {
        if (!databaseLocation.getParentFile().mkdirs() && !databaseLocation.getParentFile().exists())
            throw new IOException("Unable to create database directory");

        Connection conn = DriverManager.getConnection("jdbc:sqlite:" + databaseLocation.getAbsolutePath());
        Statement stmt = conn.createStatement();

        stmt.executeUpdate("CREATE TABLE IF NOT EXISTS LibraryFolder (path TEXT PRIMARY KEY)");

        StringBuilder builderFileTable = new StringBuilder();
        builderFileTable.append("CREATE TABLE IF NOT EXISTS LibraryFile (file_id INTEGER PRIMARY KEY AUTOINCREMENT, path TEXT UNIQUE");
        for (ID3Helper.ID3Tag id3Tag : ID3Helper.ID3Tag.values()) {
            builderFileTable
                    .append(", ")
                    .append(id3Tag.toString().toLowerCase())
                    .append(" TEXT");
        }
        builderFileTable.append(")");
        stmt.executeUpdate(builderFileTable.toString());
        conn.close();
    }

    /**/

    SQLiteTemplates sqLiteTemplate = new SQLiteTemplates();
    Configuration config = new Configuration(sqLiteTemplate);

    SQLiteDataSource dataSource = new SQLiteDataSource();
    dataSource.setUrl("jdbc:sqlite:" + databaseLocation.getAbsolutePath());

    queryFactory = new SQLQueryFactory(config, dataSource);

    reloadFiles();
    reloadFolders();
}
 

import com.querydsl.sql.Configuration; //导入依赖的package包/类
private Long getDateRangeId(final Long userHolidayAmountId, final Connection connection,
    final Configuration configuration) {

  QDateRange qDateRange = QDateRange.dateRange;
  QUserHolidayAmount qUserHolidayAmount = QUserHolidayAmount.userHolidayAmount;

  Long dateRangeId = new SQLQuery<Long>(connection, configuration)
      .select(qDateRange.dateRangeId)
      .from(qUserHolidayAmount)
      .innerJoin(qUserHolidayAmount.fk.dateRangeFK, qDateRange)
      .where(qUserHolidayAmount.userHolidayAmountId.eq(userHolidayAmountId))
      .fetchOne();

  return dateRangeId;
}
 

import com.querydsl.sql.Configuration; //导入依赖的package包/类
private void removeAllExactWorkFromScheme(final long schemeId, final Connection connection,
    final Configuration configuration) {

  QExactWork qExactWork = QExactWork.exactWork;
  new SQLDeleteClause(connection, configuration, qExactWork)
      .where(qExactWork.workSchemeId.eq(schemeId)).execute();
}
 

import com.querydsl.sql.Configuration; //导入依赖的package包/类
private void removeAllRegularWorkTimesFromScheme(final long schemeId, final Connection connection,
    final Configuration configuration) {

  QWeekdayWork qWeekdayWork = QWeekdayWork.weekdayWork;
  new SQLDeleteClause(connection, configuration, qWeekdayWork)
      .where(qWeekdayWork.workSchemeId.eq(schemeId)).execute();
}
 

import com.querydsl.sql.Configuration; //导入依赖的package包/类
private void flushDateBatch(final List<Date> dateBatch, final Connection connection,
    final Configuration configuration) {

  QDateSequence dateSequence = QDateSequence.dateSequence;
  SQLInsertClause insertClause = new SQLInsertClause(connection, configuration, dateSequence);
  for (Date date : dateBatch) {
    insertClause.set(dateSequence.date, date).addBatch();
  }
  insertClause.execute();
  dateBatch.clear();

}
 

import com.querydsl.sql.Configuration; //导入依赖的package包/类
public TransactionInstancesHolder(DataSource realDataSource) {
	try {
		Connection realConnection = realDataSource.getConnection();
		mockedConnection = new ConnectionMocked(realConnection);
		mockedDataSource = new DataSourceMocked(mockedConnection);

		transactionManager = new TransactionManagerQuerydsl(
			mockedDataSource,
			new Configuration(H2Templates.DEFAULT)
		);
	} catch (SQLException e) {
		throw new RuntimeException(e);
	}
}
 

import com.querydsl.sql.Configuration; //导入依赖的package包/类
@Inject
public HibernateToQuerydslBridge(Config config,
		TransactionManagerHibernate transactionManagerHibernate) {
	String hibernateDialect = config.getObject("db").get("hibernate.dialect").toString();

	this.transactionManagerQuerydsl = new TransactionManagerQuerydsl(
		transactionManagerHibernate.dataSource(),
		new Configuration(toSQLTemplates(hibernateDialect))
	);
}
 

import com.querydsl.sql.Configuration; //导入依赖的package包/类
public static void registerTypes(String tablePrefix, Configuration configuration) {
    configuration.register(tablePrefix + "VERSION", "TYPE", new EnumByNameType<>(VersionType.class));
    configuration.register(tablePrefix + "VERSION", "REVISION", REVISION_TYPE);
    configuration.register(tablePrefix + "VERSION", "STATUS", VERSION_STATUS_TYPE);

    configuration.register(tablePrefix + "VERSION_PARENT", "REVISION", REVISION_TYPE);
    configuration.register(tablePrefix + "VERSION_PARENT", "PARENT_REVISION", REVISION_TYPE);
    configuration.register(tablePrefix + "VERSION_PARENT", "STATUS", VERSION_STATUS_TYPE);

    configuration.register(tablePrefix + "VERSION_PROPERTY", "REVISION", REVISION_TYPE);
    configuration.register(tablePrefix + "VERSION_PROPERTY", "STATUS", VERSION_STATUS_TYPE);
}
 

import com.querydsl.sql.Configuration; //导入依赖的package包/类
private void removeAllPublicHolidays(final long schemeId, final Connection connection,
    final Configuration configuration) {
  QPublicHoliday qPublicHoliday = QPublicHoliday.publicHoliday;
  new SQLDeleteClause(connection, configuration, qPublicHoliday)
      .where(qPublicHoliday.holidaySchemeId.eq(schemeId)).execute();
}
 

import com.querydsl.sql.Configuration; //导入依赖的package包/类
public DateRangeUtil(final Connection connection, final Configuration configuration) {
  this.connection = connection;
  this.configuration = configuration;
}
 

import com.querydsl.sql.Configuration; //导入依赖的package包/类
public TransactionManagerQuerydsl(Config config, String prefix) {
	super(config, prefix);

	String dialect = config.getString(prefix + ".dialect");
	this.querydslConfiguration = new Configuration(QuerydslTemplates.valueOf(dialect).sqlTemplates());
}
 

import com.querydsl.sql.Configuration; //导入依赖的package包/类
/**
 * Function of the functional interface.
 *
 * @param connection
 *          An opened database connection.
 * @param configuration
 *          The Querydsl configuration that should be used for Querydsl queries.
 * @return An optional return value.
 * @throws SQLException
 *           The exceptions that are thrown from the function calls of connection will be
 *           translated by Querydsl.
 */
R call(Connection connection, Configuration configuration) throws SQLException;