Package cn.vertxup.erp.domain.tables.daos

Class EIdentityDao

    • Constructor Detail

      • EIdentityDao

        public EIdentityDao​(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

      • findManyByCode

        public io.vertx.core.Future<List<EIdentity>> findManyByCode​(Collection<String> values)
        Find records that have CODE IN (values) asynchronously

      • findManyByCode

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

      • findManyByType

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

      • findManyByType

        public io.vertx.core.Future<List<EIdentity>> 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<EIdentity>> findManyByStatus​(Collection<String> values)
        Find records that have STATUS IN (values) asynchronously

      • findManyByStatus

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

      • findManyByCountry

        public io.vertx.core.Future<List<EIdentity>> findManyByCountry​(Collection<String> values)
        Find records that have COUNTRY IN (values) asynchronously

      • findManyByCountry

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

      • findManyByNativePlace

        public io.vertx.core.Future<List<EIdentity>> findManyByNativePlace​(Collection<String> values)
        Find records that have NATIVE_PLACE IN (values) asynchronously

      • findManyByNativePlace

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

      • findManyByNation

        public io.vertx.core.Future<List<EIdentity>> findManyByNation​(Collection<String> values)
        Find records that have NATION IN (values) asynchronously

      • findManyByNation

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

      • findManyByAddress

        public io.vertx.core.Future<List<EIdentity>> findManyByAddress​(Collection<String> values)
        Find records that have ADDRESS IN (values) asynchronously

      • findManyByAddress

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

      • findManyByRealname

        public io.vertx.core.Future<List<EIdentity>> findManyByRealname​(Collection<String> values)
        Find records that have REALNAME IN (values) asynchronously

      • findManyByRealname

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

      • findManyByBirthday

        public io.vertx.core.Future<List<EIdentity>> findManyByBirthday​(Collection<LocalDateTime> values)
        Find records that have BIRTHDAY IN (values) asynchronously

      • findManyByBirthday

        public io.vertx.core.Future<List<EIdentity>> findManyByBirthday​(Collection<LocalDateTime> values,
                                                                int limit)
        Find records that have BIRTHDAY IN (values) asynchronously limited by the given limit

      • findManyByDriverLicense

        public io.vertx.core.Future<List<EIdentity>> findManyByDriverLicense​(Collection<String> values)
        Find records that have DRIVER_LICENSE IN (values) asynchronously

      • findManyByDriverLicense

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

      • findManyByCarPlate

        public io.vertx.core.Future<List<EIdentity>> findManyByCarPlate​(Collection<String> values)
        Find records that have CAR_PLATE IN (values) asynchronously

      • findManyByCarPlate

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

      • findManyByPassport

        public io.vertx.core.Future<List<EIdentity>> findManyByPassport​(Collection<String> values)
        Find records that have PASSPORT IN (values) asynchronously

      • findManyByPassport

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

      • findManyByGender

        public io.vertx.core.Future<List<EIdentity>> findManyByGender​(Collection<Boolean> values)
        Find records that have GENDER IN (values) asynchronously

      • findManyByGender

        public io.vertx.core.Future<List<EIdentity>> findManyByGender​(Collection<Boolean> values,
                                                              int limit)
        Find records that have GENDER IN (values) asynchronously limited by the given limit

      • findManyByMarital

        public io.vertx.core.Future<List<EIdentity>> findManyByMarital​(Collection<String> values)
        Find records that have MARITAL IN (values) asynchronously

      • findManyByMarital

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

      • findManyByContactMobile

        public io.vertx.core.Future<List<EIdentity>> findManyByContactMobile​(Collection<String> values)
        Find records that have CONTACT_MOBILE IN (values) asynchronously

      • findManyByContactMobile

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

      • findManyByContactPhone

        public io.vertx.core.Future<List<EIdentity>> findManyByContactPhone​(Collection<String> values)
        Find records that have CONTACT_PHONE IN (values) asynchronously

      • findManyByContactPhone

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

      • findManyByContactAddress

        public io.vertx.core.Future<List<EIdentity>> findManyByContactAddress​(Collection<String> values)
        Find records that have CONTACT_ADDRESS IN (values) asynchronously

      • findManyByContactAddress

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

      • findManyByContactEmail

        public io.vertx.core.Future<List<EIdentity>> findManyByContactEmail​(Collection<String> values)
        Find records that have CONTACT_EMAIL IN (values) asynchronously

      • findManyByContactEmail

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

      • findManyByUrgentName

        public io.vertx.core.Future<List<EIdentity>> findManyByUrgentName​(Collection<String> values)
        Find records that have URGENT_NAME IN (values) asynchronously

      • findManyByUrgentName

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

      • findManyByUrgentPhone

        public io.vertx.core.Future<List<EIdentity>> findManyByUrgentPhone​(Collection<String> values)
        Find records that have URGENT_PHONE IN (values) asynchronously

      • findManyByUrgentPhone

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

      • findManyByEcQq

        public io.vertx.core.Future<List<EIdentity>> findManyByEcQq​(Collection<String> values)
        Find records that have EC_QQ IN (values) asynchronously

      • findManyByEcQq

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

      • findManyByEcAlipay

        public io.vertx.core.Future<List<EIdentity>> findManyByEcAlipay​(Collection<String> values)
        Find records that have EC_ALIPAY IN (values) asynchronously

      • findManyByEcAlipay

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

      • findManyByEcWechat

        public io.vertx.core.Future<List<EIdentity>> findManyByEcWechat​(Collection<String> values)
        Find records that have EC_WECHAT IN (values) asynchronously

      • findManyByEcWechat

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

      • findManyByIdcType

        public io.vertx.core.Future<List<EIdentity>> findManyByIdcType​(Collection<String> values)
        Find records that have IDC_TYPE IN (values) asynchronously

      • findManyByIdcType

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

      • findManyByIdcNumber

        public io.vertx.core.Future<List<EIdentity>> findManyByIdcNumber​(Collection<String> values)
        Find records that have IDC_NUMBER IN (values) asynchronously

      • findManyByIdcNumber

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

      • findManyByIdcAddress

        public io.vertx.core.Future<List<EIdentity>> findManyByIdcAddress​(Collection<String> values)
        Find records that have IDC_ADDRESS IN (values) asynchronously

      • findManyByIdcAddress

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

      • findManyByIdcExpiredAt

        public io.vertx.core.Future<List<EIdentity>> findManyByIdcExpiredAt​(Collection<LocalDateTime> values)
        Find records that have IDC_EXPIRED_AT IN (values) asynchronously

      • findManyByIdcExpiredAt

        public io.vertx.core.Future<List<EIdentity>> findManyByIdcExpiredAt​(Collection<LocalDateTime> values,
                                                                    int limit)
        Find records that have IDC_EXPIRED_AT IN (values) asynchronously limited by the given limit

      • findManyByIdcFront

        public io.vertx.core.Future<List<EIdentity>> findManyByIdcFront​(Collection<String> values)
        Find records that have IDC_FRONT IN (values) asynchronously

      • findManyByIdcFront

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

      • findManyByIdcBack

        public io.vertx.core.Future<List<EIdentity>> findManyByIdcBack​(Collection<String> values)
        Find records that have IDC_BACK IN (values) asynchronously

      • findManyByIdcBack

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

      • findManyByIdcIssuer

        public io.vertx.core.Future<List<EIdentity>> findManyByIdcIssuer​(Collection<String> values)
        Find records that have IDC_ISSUER IN (values) asynchronously

      • findManyByIdcIssuer

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

      • findManyByIdcIssueAt

        public io.vertx.core.Future<List<EIdentity>> findManyByIdcIssueAt​(Collection<LocalDateTime> values)
        Find records that have IDC_ISSUE_AT IN (values) asynchronously

      • findManyByIdcIssueAt

        public io.vertx.core.Future<List<EIdentity>> findManyByIdcIssueAt​(Collection<LocalDateTime> values,
                                                                  int limit)
        Find records that have IDC_ISSUE_AT IN (values) asynchronously limited by the given limit

      • findManyByVerified

        public io.vertx.core.Future<List<EIdentity>> findManyByVerified​(Collection<Boolean> values)
        Find records that have VERIFIED IN (values) asynchronously

      • findManyByVerified

        public io.vertx.core.Future<List<EIdentity>> findManyByVerified​(Collection<Boolean> values,
                                                                int limit)
        Find records that have VERIFIED IN (values) asynchronously limited by the given limit

      • findManyByMetadata

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

      • findManyByMetadata

        public io.vertx.core.Future<List<EIdentity>> 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<EIdentity>> findManyByActive​(Collection<Boolean> values)
        Find records that have ACTIVE IN (values) asynchronously

      • findManyByActive

        public io.vertx.core.Future<List<EIdentity>> 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<EIdentity>> findManyBySigma​(Collection<String> values)
        Find records that have SIGMA IN (values) asynchronously

      • findManyBySigma

        public io.vertx.core.Future<List<EIdentity>> 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<EIdentity>> findManyByLanguage​(Collection<String> values)
        Find records that have LANGUAGE IN (values) asynchronously

      • findManyByLanguage

        public io.vertx.core.Future<List<EIdentity>> 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<EIdentity>> findManyByCreatedAt​(Collection<LocalDateTime> values)
        Find records that have CREATED_AT IN (values) asynchronously

      • findManyByCreatedAt

        public io.vertx.core.Future<List<EIdentity>> 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<EIdentity>> findManyByCreatedBy​(Collection<String> values)
        Find records that have CREATED_BY IN (values) asynchronously

      • findManyByCreatedBy

        public io.vertx.core.Future<List<EIdentity>> 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<EIdentity>> findManyByUpdatedAt​(Collection<LocalDateTime> values)
        Find records that have UPDATED_AT IN (values) asynchronously

      • findManyByUpdatedAt

        public io.vertx.core.Future<List<EIdentity>> 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<EIdentity>> findManyByUpdatedBy​(Collection<String> values)
        Find records that have UPDATED_BY IN (values) asynchronously

      • findManyByUpdatedBy

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