Class UiColumnDao

    • Constructor Detail

      • UiColumnDao

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

      • findManyByTitle

        public io.vertx.core.Future<List<UiColumn>> findManyByTitle​(Collection<String> values)
        Find records that have TITLE IN (values) asynchronously
      • findManyByTitle

        public io.vertx.core.Future<List<UiColumn>> findManyByTitle​(Collection<String> values,
                                                                    int limit)
        Find records that have TITLE IN (values) asynchronously limited by the given limit
      • findManyByDataIndex

        public io.vertx.core.Future<List<UiColumn>> findManyByDataIndex​(Collection<String> values)
        Find records that have DATA_INDEX IN (values) asynchronously
      • findManyByDataIndex

        public io.vertx.core.Future<List<UiColumn>> findManyByDataIndex​(Collection<String> values,
                                                                        int limit)
        Find records that have DATA_INDEX IN (values) asynchronously limited by the given limit
      • findManyByPosition

        public io.vertx.core.Future<List<UiColumn>> findManyByPosition​(Collection<Integer> values)
        Find records that have POSITION IN (values) asynchronously
      • findManyByPosition

        public io.vertx.core.Future<List<UiColumn>> findManyByPosition​(Collection<Integer> values,
                                                                       int limit)
        Find records that have POSITION IN (values) asynchronously limited by the given limit
      • findManyByRender

        public io.vertx.core.Future<List<UiColumn>> findManyByRender​(Collection<String> values)
        Find records that have RENDER IN (values) asynchronously
      • findManyByRender

        public io.vertx.core.Future<List<UiColumn>> findManyByRender​(Collection<String> values,
                                                                     int limit)
        Find records that have RENDER IN (values) asynchronously limited by the given limit
      • findManyByWidth

        public io.vertx.core.Future<List<UiColumn>> findManyByWidth​(Collection<Integer> values)
        Find records that have WIDTH IN (values) asynchronously
      • findManyByWidth

        public io.vertx.core.Future<List<UiColumn>> findManyByWidth​(Collection<Integer> values,
                                                                    int limit)
        Find records that have WIDTH IN (values) asynchronously limited by the given limit
      • findManyByFixed

        public io.vertx.core.Future<List<UiColumn>> findManyByFixed​(Collection<Boolean> values)
        Find records that have FIXED IN (values) asynchronously
      • findManyByFixed

        public io.vertx.core.Future<List<UiColumn>> findManyByFixed​(Collection<Boolean> values,
                                                                    int limit)
        Find records that have FIXED IN (values) asynchronously limited by the given limit
      • findManyByClassName

        public io.vertx.core.Future<List<UiColumn>> findManyByClassName​(Collection<String> values)
        Find records that have CLASS_NAME IN (values) asynchronously
      • findManyByClassName

        public io.vertx.core.Future<List<UiColumn>> findManyByClassName​(Collection<String> values,
                                                                        int limit)
        Find records that have CLASS_NAME IN (values) asynchronously limited by the given limit
      • findManyBySorter

        public io.vertx.core.Future<List<UiColumn>> findManyBySorter​(Collection<Boolean> values)
        Find records that have SORTER IN (values) asynchronously
      • findManyBySorter

        public io.vertx.core.Future<List<UiColumn>> findManyBySorter​(Collection<Boolean> values,
                                                                     int limit)
        Find records that have SORTER IN (values) asynchronously limited by the given limit
      • findManyByFilterType

        public io.vertx.core.Future<List<UiColumn>> findManyByFilterType​(Collection<String> values)
        Find records that have FILTER_TYPE IN (values) asynchronously
      • findManyByFilterType

        public io.vertx.core.Future<List<UiColumn>> findManyByFilterType​(Collection<String> values,
                                                                         int limit)
        Find records that have FILTER_TYPE IN (values) asynchronously limited by the given limit
      • findManyByFilterConfig

        public io.vertx.core.Future<List<UiColumn>> findManyByFilterConfig​(Collection<String> values)
        Find records that have FILTER_CONFIG IN (values) asynchronously
      • findManyByFilterConfig

        public io.vertx.core.Future<List<UiColumn>> findManyByFilterConfig​(Collection<String> values,
                                                                           int limit)
        Find records that have FILTER_CONFIG IN (values) asynchronously limited by the given limit
      • findManyByEmpty

        public io.vertx.core.Future<List<UiColumn>> findManyByEmpty​(Collection<String> values)
        Find records that have EMPTY IN (values) asynchronously
      • findManyByEmpty

        public io.vertx.core.Future<List<UiColumn>> findManyByEmpty​(Collection<String> values,
                                                                    int limit)
        Find records that have EMPTY IN (values) asynchronously limited by the given limit
      • findManyByMapping

        public io.vertx.core.Future<List<UiColumn>> findManyByMapping​(Collection<String> values)
        Find records that have MAPPING IN (values) asynchronously
      • findManyByMapping

        public io.vertx.core.Future<List<UiColumn>> findManyByMapping​(Collection<String> values,
                                                                      int limit)
        Find records that have MAPPING IN (values) asynchronously limited by the given limit
      • findManyByConfig

        public io.vertx.core.Future<List<UiColumn>> findManyByConfig​(Collection<String> values)
        Find records that have CONFIG IN (values) asynchronously
      • findManyByConfig

        public io.vertx.core.Future<List<UiColumn>> findManyByConfig​(Collection<String> values,
                                                                     int limit)
        Find records that have CONFIG IN (values) asynchronously limited by the given limit
      • findManyByOption

        public io.vertx.core.Future<List<UiColumn>> findManyByOption​(Collection<String> values)
        Find records that have OPTION IN (values) asynchronously
      • findManyByOption

        public io.vertx.core.Future<List<UiColumn>> findManyByOption​(Collection<String> values,
                                                                     int limit)
        Find records that have OPTION IN (values) asynchronously limited by the given limit
      • findManyByFormat

        public io.vertx.core.Future<List<UiColumn>> findManyByFormat​(Collection<String> values)
        Find records that have FORMAT IN (values) asynchronously
      • findManyByFormat

        public io.vertx.core.Future<List<UiColumn>> findManyByFormat​(Collection<String> values,
                                                                     int limit)
        Find records that have FORMAT IN (values) asynchronously limited by the given limit
      • findManyByDatum

        public io.vertx.core.Future<List<UiColumn>> findManyByDatum​(Collection<String> values)
        Find records that have DATUM IN (values) asynchronously
      • findManyByDatum

        public io.vertx.core.Future<List<UiColumn>> findManyByDatum​(Collection<String> values,
                                                                    int limit)
        Find records that have DATUM IN (values) asynchronously limited by the given limit
      • findManyByControlId

        public io.vertx.core.Future<List<UiColumn>> findManyByControlId​(Collection<String> values)
        Find records that have CONTROL_ID IN (values) asynchronously
      • findManyByControlId

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

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

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

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

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

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

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

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

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

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

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

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