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

Class EAssetDao

    • Constructor Detail

      • EAssetDao

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

      • findManyByName

        public io.vertx.core.Future<List<EAsset>> findManyByName​(Collection<String> values)
        Find records that have NAME IN (values) asynchronously

      • findManyByName

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

      • findManyByCode

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

      • findManyByCode

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

      • findManyByType

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

      • findManyByStatus

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

      • findManyByModelNumber

        public io.vertx.core.Future<List<EAsset>> findManyByModelNumber​(Collection<String> values)
        Find records that have MODEL_NUMBER IN (values) asynchronously

      • findManyByModelNumber

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

      • findManyByUnit

        public io.vertx.core.Future<List<EAsset>> findManyByUnit​(Collection<String> values)
        Find records that have UNIT IN (values) asynchronously

      • findManyByUnit

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

      • findManyByNum

        public io.vertx.core.Future<List<EAsset>> findManyByNum​(Collection<Long> values)
        Find records that have NUM IN (values) asynchronously

      • findManyByNum

        public io.vertx.core.Future<List<EAsset>> findManyByNum​(Collection<Long> values,
                                                        int limit)
        Find records that have NUM IN (values) asynchronously limited by the given limit

      • findManyByNumDeprecating

        public io.vertx.core.Future<List<EAsset>> findManyByNumDeprecating​(Collection<Long> values)
        Find records that have NUM_DEPRECATING IN (values) asynchronously

      • findManyByNumDeprecating

        public io.vertx.core.Future<List<EAsset>> findManyByNumDeprecating​(Collection<Long> values,
                                                                   int limit)
        Find records that have NUM_DEPRECATING IN (values) asynchronously limited by the given limit

      • findManyByNumDeprecated

        public io.vertx.core.Future<List<EAsset>> findManyByNumDeprecated​(Collection<Long> values)
        Find records that have NUM_DEPRECATED IN (values) asynchronously

      • findManyByNumDeprecated

        public io.vertx.core.Future<List<EAsset>> findManyByNumDeprecated​(Collection<Long> values,
                                                                  int limit)
        Find records that have NUM_DEPRECATED IN (values) asynchronously limited by the given limit

      • findManyByNumUsing

        public io.vertx.core.Future<List<EAsset>> findManyByNumUsing​(Collection<Long> values)
        Find records that have NUM_USING IN (values) asynchronously

      • findManyByNumUsing

        public io.vertx.core.Future<List<EAsset>> findManyByNumUsing​(Collection<Long> values,
                                                             int limit)
        Find records that have NUM_USING IN (values) asynchronously limited by the given limit

      • findManyByNumUsed

        public io.vertx.core.Future<List<EAsset>> findManyByNumUsed​(Collection<Long> values)
        Find records that have NUM_USED IN (values) asynchronously

      • findManyByNumUsed

        public io.vertx.core.Future<List<EAsset>> findManyByNumUsed​(Collection<Long> values,
                                                            int limit)
        Find records that have NUM_USED IN (values) asynchronously limited by the given limit

      • findManyByWayChange

        public io.vertx.core.Future<List<EAsset>> findManyByWayChange​(Collection<String> values)
        Find records that have WAY_CHANGE IN (values) asynchronously

      • findManyByWayChange

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

      • findManyByWayDeprecate

        public io.vertx.core.Future<List<EAsset>> findManyByWayDeprecate​(Collection<String> values)
        Find records that have WAY_DEPRECATE IN (values) asynchronously

      • findManyByWayDeprecate

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

      • findManyByWayAccording

        public io.vertx.core.Future<List<EAsset>> findManyByWayAccording​(Collection<String> values)
        Find records that have WAY_ACCORDING IN (values) asynchronously

      • findManyByWayAccording

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

      • findManyByUsedAt

        public io.vertx.core.Future<List<EAsset>> findManyByUsedAt​(Collection<LocalDateTime> values)
        Find records that have USED_AT IN (values) asynchronously

      • findManyByUsedAt

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

      • findManyByUsedBy

        public io.vertx.core.Future<List<EAsset>> findManyByUsedBy​(Collection<String> values)
        Find records that have USED_BY IN (values) asynchronously

      • findManyByUsedBy

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

      • findManyByUsedStatus

        public io.vertx.core.Future<List<EAsset>> findManyByUsedStatus​(Collection<String> values)
        Find records that have USED_STATUS IN (values) asynchronously

      • findManyByUsedStatus

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

      • findManyByVOriginal

        public io.vertx.core.Future<List<EAsset>> findManyByVOriginal​(Collection<BigDecimal> values)
        Find records that have V_ORIGINAL IN (values) asynchronously

      • findManyByVOriginal

        public io.vertx.core.Future<List<EAsset>> findManyByVOriginal​(Collection<BigDecimal> values,
                                                              int limit)
        Find records that have V_ORIGINAL IN (values) asynchronously limited by the given limit

      • findManyByVTax

        public io.vertx.core.Future<List<EAsset>> findManyByVTax​(Collection<BigDecimal> values)
        Find records that have V_TAX IN (values) asynchronously

      • findManyByVTax

        public io.vertx.core.Future<List<EAsset>> findManyByVTax​(Collection<BigDecimal> values,
                                                         int limit)
        Find records that have V_TAX IN (values) asynchronously limited by the given limit

      • findManyByVDeReady

        public io.vertx.core.Future<List<EAsset>> findManyByVDeReady​(Collection<BigDecimal> values)
        Find records that have V_DE_READY IN (values) asynchronously

      • findManyByVDeReady

        public io.vertx.core.Future<List<EAsset>> findManyByVDeReady​(Collection<BigDecimal> values,
                                                             int limit)
        Find records that have V_DE_READY IN (values) asynchronously limited by the given limit

      • findManyByVNetJunk

        public io.vertx.core.Future<List<EAsset>> findManyByVNetJunk​(Collection<BigDecimal> values)
        Find records that have V_NET_JUNK IN (values) asynchronously

      • findManyByVNetJunk

        public io.vertx.core.Future<List<EAsset>> findManyByVNetJunk​(Collection<BigDecimal> values,
                                                             int limit)
        Find records that have V_NET_JUNK IN (values) asynchronously limited by the given limit

      • findManyByVNet

        public io.vertx.core.Future<List<EAsset>> findManyByVNet​(Collection<BigDecimal> values)
        Find records that have V_NET IN (values) asynchronously

      • findManyByVNet

        public io.vertx.core.Future<List<EAsset>> findManyByVNet​(Collection<BigDecimal> values,
                                                         int limit)
        Find records that have V_NET IN (values) asynchronously limited by the given limit

      • findManyByVNetAmount

        public io.vertx.core.Future<List<EAsset>> findManyByVNetAmount​(Collection<BigDecimal> values)
        Find records that have V_NET_AMOUNT IN (values) asynchronously

      • findManyByVNetAmount

        public io.vertx.core.Future<List<EAsset>> findManyByVNetAmount​(Collection<BigDecimal> values,
                                                               int limit)
        Find records that have V_NET_AMOUNT IN (values) asynchronously limited by the given limit

      • findManyByVDeprecatedM

        public io.vertx.core.Future<List<EAsset>> findManyByVDeprecatedM​(Collection<BigDecimal> values)
        Find records that have V_DEPRECATED_M IN (values) asynchronously

      • findManyByVDeprecatedM

        public io.vertx.core.Future<List<EAsset>> findManyByVDeprecatedM​(Collection<BigDecimal> values,
                                                                 int limit)
        Find records that have V_DEPRECATED_M IN (values) asynchronously limited by the given limit

      • findManyByVDeprecatedA

        public io.vertx.core.Future<List<EAsset>> findManyByVDeprecatedA​(Collection<BigDecimal> values)
        Find records that have V_DEPRECATED_A IN (values) asynchronously

      • findManyByVDeprecatedA

        public io.vertx.core.Future<List<EAsset>> findManyByVDeprecatedA​(Collection<BigDecimal> values,
                                                                 int limit)
        Find records that have V_DEPRECATED_A IN (values) asynchronously limited by the given limit

      • findManyByKFixed

        public io.vertx.core.Future<List<EAsset>> findManyByKFixed​(Collection<String> values)
        Find records that have K_FIXED IN (values) asynchronously

      • findManyByKFixed

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

      • findManyByKDeprecated

        public io.vertx.core.Future<List<EAsset>> findManyByKDeprecated​(Collection<String> values)
        Find records that have K_DEPRECATED IN (values) asynchronously

      • findManyByKDeprecated

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

      • findManyByKAssignment

        public io.vertx.core.Future<List<EAsset>> findManyByKAssignment​(Collection<String> values)
        Find records that have K_ASSIGNMENT IN (values) asynchronously

      • findManyByKAssignment

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

      • findManyByKTax

        public io.vertx.core.Future<List<EAsset>> findManyByKTax​(Collection<String> values)
        Find records that have K_TAX IN (values) asynchronously

      • findManyByKTax

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

      • findManyByKDevalue

        public io.vertx.core.Future<List<EAsset>> findManyByKDevalue​(Collection<String> values)
        Find records that have K_DEVALUE IN (values) asynchronously

      • findManyByKDevalue

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

      • findManyByKChange

        public io.vertx.core.Future<List<EAsset>> findManyByKChange​(Collection<String> values)
        Find records that have K_CHANGE IN (values) asynchronously

      • findManyByKChange

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

      • findManyByCustomerId

        public io.vertx.core.Future<List<EAsset>> findManyByCustomerId​(Collection<String> values)
        Find records that have CUSTOMER_ID IN (values) asynchronously

      • findManyByCustomerId

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

      • findManyByExpiredAt

        public io.vertx.core.Future<List<EAsset>> findManyByExpiredAt​(Collection<LocalDateTime> values)
        Find records that have EXPIRED_AT IN (values) asynchronously

      • findManyByExpiredAt

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

      • findManyByExpiredComment

        public io.vertx.core.Future<List<EAsset>> findManyByExpiredComment​(Collection<String> values)
        Find records that have EXPIRED_COMMENT IN (values) asynchronously

      • findManyByExpiredComment

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

      • findManyByUserId

        public io.vertx.core.Future<List<EAsset>> findManyByUserId​(Collection<String> values)
        Find records that have USER_ID IN (values) asynchronously

      • findManyByUserId

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

      • findManyByStoreId

        public io.vertx.core.Future<List<EAsset>> findManyByStoreId​(Collection<String> values)
        Find records that have STORE_ID IN (values) asynchronously

      • findManyByStoreId

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

      • findManyByDeptId

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

      • findManyByDeptId

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

      • findManyByCompanyId

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

      • findManyByCompanyId

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

      • findManyByParentId

        public io.vertx.core.Future<List<EAsset>> findManyByParentId​(Collection<String> values)
        Find records that have PARENT_ID IN (values) asynchronously

      • findManyByParentId

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

      • findManyByComment

        public io.vertx.core.Future<List<EAsset>> findManyByComment​(Collection<String> values)
        Find records that have COMMENT IN (values) asynchronously

      • findManyByComment

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

      • findManyBySigma

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

      • findManyBySigma

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

      • findManyByLanguage

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

      • findManyByActive

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

      • findManyByActive

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

      • findManyByMetadata

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

      • findManyByMetadata

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

      • findManyByEnterAt

        public io.vertx.core.Future<List<EAsset>> findManyByEnterAt​(Collection<LocalDateTime> values)
        Find records that have ENTER_AT IN (values) asynchronously

      • findManyByEnterAt

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

      • findManyByEnterBy

        public io.vertx.core.Future<List<EAsset>> findManyByEnterBy​(Collection<String> values)
        Find records that have ENTER_BY IN (values) asynchronously

      • findManyByEnterBy

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

      • findManyByAccountAt

        public io.vertx.core.Future<List<EAsset>> findManyByAccountAt​(Collection<LocalDateTime> values)
        Find records that have ACCOUNT_AT IN (values) asynchronously

      • findManyByAccountAt

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

      • findManyByAccountBy

        public io.vertx.core.Future<List<EAsset>> findManyByAccountBy​(Collection<String> values)
        Find records that have ACCOUNT_BY IN (values) asynchronously

      • findManyByAccountBy

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

      • findManyByScrapAt

        public io.vertx.core.Future<List<EAsset>> findManyByScrapAt​(Collection<LocalDateTime> values)
        Find records that have SCRAP_AT IN (values) asynchronously

      • findManyByScrapAt

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

      • findManyByScrapBy

        public io.vertx.core.Future<List<EAsset>> findManyByScrapBy​(Collection<String> values)
        Find records that have SCRAP_BY IN (values) asynchronously

      • findManyByScrapBy

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

      • findManyByCreatedAt

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

      • findManyByCreatedAt

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

      • findManyByCreatedBy

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

      • findManyByUpdatedAt

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

      • findManyByUpdatedBy

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

      • queryExecutor

        public io.github.jklingsporn.vertx.jooq.classic.jdbc.JDBCClassicQueryExecutor<EAssetRecord,​EAsset,​String> queryExecutor()
        Specified by:
        queryExecutor in interface io.github.jklingsporn.vertx.jooq.shared.internal.GenericVertxDAO<EAssetRecord,​EAsset,​String,​io.vertx.core.Future<List<EAsset>>,​io.vertx.core.Future<EAsset>,​io.vertx.core.Future<Integer>,​io.vertx.core.Future<String>>
        Overrides:
        queryExecutor in class io.github.jklingsporn.vertx.jooq.shared.internal.AbstractVertxDAO<EAssetRecord,​EAsset,​String,​io.vertx.core.Future<List<EAsset>>,​io.vertx.core.Future<EAsset>,​io.vertx.core.Future<Integer>,​io.vertx.core.Future<String>>