Examples with Table org.jooq.Table used on opensource projects

Example 26 with Table

use of org.jooq.Table in project jOOQ by jOOQ.

the class InformationSchemaExport method exportTables.

static final InformationSchema exportTables(Configuration configuration, List<Table<?>> tables) {
    InformationSchema result = new InformationSchema();
    Set<Catalog> includedCatalogs = new LinkedHashSet<>();
    Set<Schema> includedSchemas = new LinkedHashSet<>();
    Set<Table<?>> includedTables = new LinkedHashSet<>(tables);
    for (Table<?> t : tables) if (t.getSchema() != null)
        includedSchemas.add(t.getSchema());
    for (Schema s : includedSchemas) if (s.getCatalog() != null)
        includedCatalogs.add(s.getCatalog());
    for (Catalog c : includedCatalogs) exportCatalog0(result, c);
    for (Schema s : includedSchemas) exportSchema0(result, s);
    for (Table<?> t : tables) exportTable0(configuration, result, t, includedTables);
    return result;
}

Example 27 with Table

use of org.jooq.Table in project jOOQ by jOOQ.

the class InformationSchemaExport method exportSchemas.

static final InformationSchema exportSchemas(Configuration configuration, List<Schema> schemas) {
    InformationSchema result = new InformationSchema();
    Set<Catalog> includedCatalogs = new LinkedHashSet<>();
    Set<Table<?>> includedTables = new LinkedHashSet<>();
    for (Schema s : schemas) {
        if (s.getCatalog() != null)
            includedCatalogs.add(s.getCatalog());
        includedTables.addAll(s.getTables());
    }
    for (Catalog c : includedCatalogs) exportCatalog0(result, c);
    for (Schema s : schemas) {
        exportSchema0(result, s);
        for (Domain<?> d : s.getDomains()) exportDomain0(configuration, result, d);
        for (Table<?> t : s.getTables()) exportTable0(configuration, result, t, includedTables);
        for (Sequence<?> q : s.getSequences()) exportSequence0(configuration, result, q);
    }
    return result;
}

Example 28 with Table

use of org.jooq.Table in project jOOQ by jOOQ.

the class DAOImpl method records.

private /* non-final */
List<R> records(Collection<P> objects, boolean forUpdate) {
    List<R> result = new ArrayList<>(objects.size());
    Field<?>[] pk = pk();
    DSLContext ctx;
    // [#7731] Create a Record -> POJO mapping to allow for reusing the below
    // derived Configuration for improved reflection caching.
    IdentityHashMap<R, Object> mapping = !FALSE.equals(settings().isReturnRecordToPojo()) ? new IdentityHashMap<>() : null;
    // are copied back to the relevant POJO using the RecordListener SPI
    if (mapping != null) {
        Consumer<? super RecordContext> end = c -> {
            Record record = c.record();
            // TODO: [#2536] Use mapper()
            if (record != null)
                record.into(mapping.get(record));
        };
        ctx = configuration().deriveAppending(onStoreEnd(end).onInsertEnd(end).onUpdateEnd(end).onDeleteEnd(end)).dsl();
    } else
        ctx = ctx();
    for (P object : objects) {
        R record = ctx.newRecord(table, object);
        if (mapping != null)
            mapping.put(record, object);
        if (forUpdate && pk != null)
            for (Field<?> field : pk) record.changed(field, false);
        Tools.resetChangedOnNotNull(record);
        result.add(record);
    }
    return result;
}

Example 29 with Table

use of org.jooq.Table in project jOOQ by jOOQ.

the class UpdateQueryImpl method accept0.

@SuppressWarnings({ "unchecked", "rawtypes" })
@Override
final void accept0(Context<?> ctx) {
    boolean declareTables = ctx.declareTables();
    ctx.start(UPDATE_UPDATE).visit(K_UPDATE).sql(' ').declareTables(true).visit(table(ctx)).declareTables(declareTables).end(UPDATE_UPDATE);
    ctx.formatSeparator().start(UPDATE_SET).visit(K_SET).separatorRequired(true);
    // A multi-row update was specified
    if (multiRow != null) {
        // [#6884] This syntax can be emulated trivially, if the RHS is not a SELECT subquery
        if (multiValue != null && !SUPPORT_RVE_SET.contains(ctx.dialect())) {
            FieldMapForUpdate map = new FieldMapForUpdate(table(), UPDATE_SET_ASSIGNMENT);
            for (int i = 0; i < multiRow.size(); i++) {
                Field<?> k = multiRow.field(i);
                Field<?> v = multiValue.field(i);
                map.put(k, Tools.field(v, k));
            }
            ctx.formatIndentStart().formatSeparator().visit(map).formatIndentEnd();
        } else {
            Row row = removeReadonly(ctx, multiRow);
            ctx.start(UPDATE_SET_ASSIGNMENT).formatIndentStart().formatSeparator().qualify(false, c -> c.visit(row)).sql(" = ");
            // right hand side of a SET clause
            if (multiValue != null) {
                // single-degree rows. Let's just always render it, here.
                if (REQUIRE_RVE_ROW_CLAUSE.contains(ctx.dialect()))
                    ctx.visit(K_ROW).sql(" ");
                ctx.visit(removeReadonly(ctx, multiRow, multiValue));
            } else // Subselects or subselect emulations of row value expressions
            {
                Select<?> select;
                if (multiValue != null)
                    select = select(removeReadonly(ctx, multiRow, multiValue).fields());
                else
                    select = multiSelect;
                visitSubquery(ctx, select, false, false, false);
            }
            ctx.formatIndentEnd().end(UPDATE_SET_ASSIGNMENT);
        }
    } else // A regular (non-multi-row) update was specified
    {
        ctx.formatIndentStart().formatSeparator().visit(updateMap).formatIndentEnd();
    }
    ctx.end(UPDATE_SET);
    switch(ctx.family()) {
        default:
            acceptFrom(ctx);
            break;
    }
    if (limit != null && NO_SUPPORT_LIMIT.contains(ctx.dialect()) || !orderBy.isEmpty() && NO_SUPPORT_ORDER_BY_LIMIT.contains(ctx.dialect())) {
        Field<?>[] keyFields = table().getKeys().isEmpty() ? new Field[] { table().rowid() } : (table().getPrimaryKey() != null ? table().getPrimaryKey() : table().getKeys().get(0)).getFieldsArray();
        ctx.start(UPDATE_WHERE).formatSeparator().visit(K_WHERE).sql(' ');
        if (keyFields.length == 1)
            ctx.visit(keyFields[0].in(select((Field) keyFields[0]).from(table()).where(getWhere()).orderBy(orderBy).limit(limit)));
        else
            ctx.visit(row(keyFields).in(select(keyFields).from(table()).where(getWhere()).orderBy(orderBy).limit(limit)));
        ctx.end(UPDATE_WHERE);
    } else {
        ctx.start(UPDATE_WHERE);
        if (hasWhere())
            ctx.formatSeparator().visit(K_WHERE).sql(' ').visit(getWhere());
        ctx.end(UPDATE_WHERE);
        if (!orderBy.isEmpty())
            ctx.formatSeparator().visit(K_ORDER_BY).sql(' ').visit(orderBy);
        if (limit != null)
            ctx.formatSeparator().visit(K_LIMIT).sql(' ').visit(limit);
    }
    ctx.start(UPDATE_RETURNING);
    toSQLReturning(ctx);
    ctx.end(UPDATE_RETURNING);
}

Example 30 with Table

use of org.jooq.Table in project jOOQ by jOOQ.

the class Alias method acceptDeclareAliasStandard.

private final void acceptDeclareAliasStandard(Context<?> context) {
    if (wrapped instanceof TableImpl)
        context.scopeMarkStart(wrapping);
    SQLDialect dialect = context.dialect();
    SQLDialect family = context.family();
    boolean emulatedDerivedColumnList = false;
    // Hence, wrap the table reference in a subselect
    if (fieldAliases != null && (SUPPORT_DERIVED_COLUMN_NAMES_SPECIAL1.contains(dialect)) && (wrapped instanceof TableImpl || wrapped instanceof CommonTableExpressionImpl)) {
        visitSubquery(context, select(asterisk()).from(((Table<?>) wrapped).as(alias)), true, false, false);
    } else // results using UNION ALL
    if (fieldAliases != null && (emulatedDerivedColumnList || SUPPORT_DERIVED_COLUMN_NAMES_SPECIAL2.contains(dialect))) {
        emulatedDerivedColumnList = true;
        if (wrapped instanceof Values && NO_SUPPORT_VALUES.contains(dialect)) {
            context.data(DATA_SELECT_ALIASES, fieldAliases, t -> toSQLWrapped(t));
        } else {
            // [#3156] Do not SELECT * from derived tables to prevent ambiguously defined columns
            // in those derived tables
            Select<?> wrappedAsSelect = wrapped instanceof Select ? (Select<?>) wrapped : wrapped instanceof DerivedTable ? ((DerivedTable<?>) wrapped).query() : select(asterisk()).from(((Table<?>) wrapped).as(alias));
            List<Field<?>> select = wrappedAsSelect.getSelect();
            if (emulatedDerivedColumnList) {
                SelectFieldList<Field<?>> fields = new SelectFieldList<>();
                for (int i = 0; i < fieldAliases.length; i++) {
                    switch(family) {
                        default:
                            fields.add(field("null").as(fieldAliases[i]));
                            break;
                    }
                }
                visitSubquery(context, select(fields).where(falseCondition()).unionAll(wrappedAsSelect), true, false, false);
            }
        }
    } else
        // The default behaviour
        toSQLWrapped(context);
    // [#291] some aliases cause trouble, if they are not explicitly marked using "as"
    toSQLAs(context);
    context.sql(' ').qualify(false, c -> c.visit(alias));
    // [#1801] Add field aliases to the table alias, if applicable
    if (fieldAliases != null && !emulatedDerivedColumnList) {
        toSQLDerivedColumnList(context);
    } else {
        // TODO: Is this still needed?
        switch(family) {
            case HSQLDB:
            case POSTGRES:
            case YUGABYTEDB:
                {
                    // The javac compiler doesn't like casting of generics
                    Object o = wrapped;
                    if (context.declareTables() && o instanceof ArrayTable)
                        context.sql('(').visit(wrap(((ArrayTable) o).fields()).qualify(false)).sql(')');
                    break;
                }
        }
    }
    if (wrapped instanceof TableImpl)
        context.scopeMarkEnd(wrapping);
}