Class EEmployeeDao

    • Constructor Detail

      • EEmployeeDao

        public EEmployeeDao​(org.jooq.Configuration configuration,
                            io.vertx.core.Vertx vertx)
        Parameters:
        configuration - The Configuration used for rendering and query execution. * @param vertx the vertx instance
    • Method Detail

      • findManyByCompanyId

        public io.vertx.core.Future<List<EEmployee>> findManyByCompanyId​(Collection<String> values)
        Find records that have COMPANY_ID IN (values) asynchronously
      • findManyByCompanyId

        public io.vertx.core.Future<List<EEmployee>> findManyByCompanyId​(Collection<String> values,
                                                                         int limit)
        Find records that have COMPANY_ID IN (values) asynchronously limited by the given limit
      • findManyByDeptId

        public io.vertx.core.Future<List<EEmployee>> findManyByDeptId​(Collection<String> values)
        Find records that have DEPT_ID IN (values) asynchronously
      • findManyByDeptId

        public io.vertx.core.Future<List<EEmployee>> findManyByDeptId​(Collection<String> values,
                                                                      int limit)
        Find records that have DEPT_ID IN (values) asynchronously limited by the given limit
      • findManyByTeamId

        public io.vertx.core.Future<List<EEmployee>> findManyByTeamId​(Collection<String> values)
        Find records that have TEAM_ID IN (values) asynchronously
      • findManyByTeamId

        public io.vertx.core.Future<List<EEmployee>> findManyByTeamId​(Collection<String> values,
                                                                      int limit)
        Find records that have TEAM_ID IN (values) asynchronously limited by the given limit
      • findManyByIdentityId

        public io.vertx.core.Future<List<EEmployee>> findManyByIdentityId​(Collection<String> values)
        Find records that have IDENTITY_ID IN (values) asynchronously
      • findManyByIdentityId

        public io.vertx.core.Future<List<EEmployee>> findManyByIdentityId​(Collection<String> values,
                                                                          int limit)
        Find records that have IDENTITY_ID IN (values) asynchronously limited by the given limit
      • findManyByViceName

        public io.vertx.core.Future<List<EEmployee>> findManyByViceName​(Collection<String> values)
        Find records that have VICE_NAME IN (values) asynchronously
      • findManyByViceName

        public io.vertx.core.Future<List<EEmployee>> findManyByViceName​(Collection<String> values,
                                                                        int limit)
        Find records that have VICE_NAME IN (values) asynchronously limited by the given limit
      • findManyByViceEmail

        public io.vertx.core.Future<List<EEmployee>> findManyByViceEmail​(Collection<String> values)
        Find records that have VICE_EMAIL IN (values) asynchronously
      • findManyByViceEmail

        public io.vertx.core.Future<List<EEmployee>> findManyByViceEmail​(Collection<String> values,
                                                                         int limit)
        Find records that have VICE_EMAIL IN (values) asynchronously limited by the given limit
      • findManyByViceMobile

        public io.vertx.core.Future<List<EEmployee>> findManyByViceMobile​(Collection<String> values)
        Find records that have VICE_MOBILE IN (values) asynchronously
      • findManyByViceMobile

        public io.vertx.core.Future<List<EEmployee>> findManyByViceMobile​(Collection<String> values,
                                                                          int limit)
        Find records that have VICE_MOBILE IN (values) asynchronously limited by the given limit
      • findManyByWorkNumber

        public io.vertx.core.Future<List<EEmployee>> findManyByWorkNumber​(Collection<String> values)
        Find records that have WORK_NUMBER IN (values) asynchronously
      • findManyByWorkNumber

        public io.vertx.core.Future<List<EEmployee>> findManyByWorkNumber​(Collection<String> values,
                                                                          int limit)
        Find records that have WORK_NUMBER IN (values) asynchronously limited by the given limit
      • findManyByWorkTitle

        public io.vertx.core.Future<List<EEmployee>> findManyByWorkTitle​(Collection<String> values)
        Find records that have WORK_TITLE IN (values) asynchronously
      • findManyByWorkTitle

        public io.vertx.core.Future<List<EEmployee>> findManyByWorkTitle​(Collection<String> values,
                                                                         int limit)
        Find records that have WORK_TITLE IN (values) asynchronously limited by the given limit
      • findManyByWorkLocation

        public io.vertx.core.Future<List<EEmployee>> findManyByWorkLocation​(Collection<String> values)
        Find records that have WORK_LOCATION IN (values) asynchronously
      • findManyByWorkLocation

        public io.vertx.core.Future<List<EEmployee>> findManyByWorkLocation​(Collection<String> values,
                                                                            int limit)
        Find records that have WORK_LOCATION IN (values) asynchronously limited by the given limit
      • findManyByWorkPhone

        public io.vertx.core.Future<List<EEmployee>> findManyByWorkPhone​(Collection<String> values)
        Find records that have WORK_PHONE IN (values) asynchronously
      • findManyByWorkPhone

        public io.vertx.core.Future<List<EEmployee>> findManyByWorkPhone​(Collection<String> values,
                                                                         int limit)
        Find records that have WORK_PHONE IN (values) asynchronously limited by the given limit
      • findManyByWorkExtension

        public io.vertx.core.Future<List<EEmployee>> findManyByWorkExtension​(Collection<String> values)
        Find records that have WORK_EXTENSION IN (values) asynchronously
      • findManyByWorkExtension

        public io.vertx.core.Future<List<EEmployee>> findManyByWorkExtension​(Collection<String> values,
                                                                             int limit)
        Find records that have WORK_EXTENSION IN (values) asynchronously limited by the given limit
      • findManyByWorkHireAt

        public io.vertx.core.Future<List<EEmployee>> findManyByWorkHireAt​(Collection<LocalDateTime> values)
        Find records that have WORK_HIRE_AT IN (values) asynchronously
      • findManyByWorkHireAt

        public io.vertx.core.Future<List<EEmployee>> findManyByWorkHireAt​(Collection<LocalDateTime> values,
                                                                          int limit)
        Find records that have WORK_HIRE_AT IN (values) asynchronously limited by the given limit
      • findManyByBankId

        public io.vertx.core.Future<List<EEmployee>> findManyByBankId​(Collection<String> values)
        Find records that have BANK_ID IN (values) asynchronously
      • findManyByBankId

        public io.vertx.core.Future<List<EEmployee>> findManyByBankId​(Collection<String> values,
                                                                      int limit)
        Find records that have BANK_ID IN (values) asynchronously limited by the given limit
      • findManyByBankCard

        public io.vertx.core.Future<List<EEmployee>> findManyByBankCard​(Collection<String> values)
        Find records that have BANK_CARD IN (values) asynchronously
      • findManyByBankCard

        public io.vertx.core.Future<List<EEmployee>> findManyByBankCard​(Collection<String> values,
                                                                        int limit)
        Find records that have BANK_CARD IN (values) asynchronously limited by the given limit
      • findManyByType

        public io.vertx.core.Future<List<EEmployee>> findManyByType​(Collection<String> values)
        Find records that have TYPE IN (values) asynchronously
      • findManyByType

        public io.vertx.core.Future<List<EEmployee>> findManyByType​(Collection<String> values,
                                                                    int limit)
        Find records that have TYPE IN (values) asynchronously limited by the given limit
      • findManyByStatus

        public io.vertx.core.Future<List<EEmployee>> findManyByStatus​(Collection<String> values)
        Find records that have STATUS IN (values) asynchronously
      • findManyByStatus

        public io.vertx.core.Future<List<EEmployee>> findManyByStatus​(Collection<String> values,
                                                                      int limit)
        Find records that have STATUS IN (values) asynchronously limited by the given limit
      • findManyByMetadata

        public io.vertx.core.Future<List<EEmployee>> findManyByMetadata​(Collection<String> values)
        Find records that have METADATA IN (values) asynchronously
      • findManyByMetadata

        public io.vertx.core.Future<List<EEmployee>> findManyByMetadata​(Collection<String> values,
                                                                        int limit)
        Find records that have METADATA IN (values) asynchronously limited by the given limit
      • findManyByActive

        public io.vertx.core.Future<List<EEmployee>> findManyByActive​(Collection<Boolean> values)
        Find records that have ACTIVE IN (values) asynchronously
      • findManyByActive

        public io.vertx.core.Future<List<EEmployee>> findManyByActive​(Collection<Boolean> values,
                                                                      int limit)
        Find records that have ACTIVE IN (values) asynchronously limited by the given limit
      • findManyBySigma

        public io.vertx.core.Future<List<EEmployee>> findManyBySigma​(Collection<String> values)
        Find records that have SIGMA IN (values) asynchronously
      • findManyBySigma

        public io.vertx.core.Future<List<EEmployee>> findManyBySigma​(Collection<String> values,
                                                                     int limit)
        Find records that have SIGMA IN (values) asynchronously limited by the given limit
      • findManyByLanguage

        public io.vertx.core.Future<List<EEmployee>> findManyByLanguage​(Collection<String> values)
        Find records that have LANGUAGE IN (values) asynchronously
      • findManyByLanguage

        public io.vertx.core.Future<List<EEmployee>> findManyByLanguage​(Collection<String> values,
                                                                        int limit)
        Find records that have LANGUAGE IN (values) asynchronously limited by the given limit
      • findManyByCreatedAt

        public io.vertx.core.Future<List<EEmployee>> findManyByCreatedAt​(Collection<LocalDateTime> values)
        Find records that have CREATED_AT IN (values) asynchronously
      • findManyByCreatedAt

        public io.vertx.core.Future<List<EEmployee>> findManyByCreatedAt​(Collection<LocalDateTime> values,
                                                                         int limit)
        Find records that have CREATED_AT IN (values) asynchronously limited by the given limit
      • findManyByCreatedBy

        public io.vertx.core.Future<List<EEmployee>> findManyByCreatedBy​(Collection<String> values)
        Find records that have CREATED_BY IN (values) asynchronously
      • findManyByCreatedBy

        public io.vertx.core.Future<List<EEmployee>> findManyByCreatedBy​(Collection<String> values,
                                                                         int limit)
        Find records that have CREATED_BY IN (values) asynchronously limited by the given limit
      • findManyByUpdatedAt

        public io.vertx.core.Future<List<EEmployee>> findManyByUpdatedAt​(Collection<LocalDateTime> values)
        Find records that have UPDATED_AT IN (values) asynchronously
      • findManyByUpdatedAt

        public io.vertx.core.Future<List<EEmployee>> findManyByUpdatedAt​(Collection<LocalDateTime> values,
                                                                         int limit)
        Find records that have UPDATED_AT IN (values) asynchronously limited by the given limit
      • findManyByUpdatedBy

        public io.vertx.core.Future<List<EEmployee>> findManyByUpdatedBy​(Collection<String> values)
        Find records that have UPDATED_BY IN (values) asynchronously
      • findManyByUpdatedBy

        public io.vertx.core.Future<List<EEmployee>> findManyByUpdatedBy​(Collection<String> values,
                                                                         int limit)
        Find records that have UPDATED_BY IN (values) asynchronously limited by the given limit