* Copyright (c) 2009-2014, Data Geekery GmbH (http://www.datageekery.com)

* All rights reserved.

*

* This work is dual-licensed

* - under the Apache Software License 2.0 (the "ASL")

* - under the jOOQ License and Maintenance Agreement (the "jOOQ License")

* =============================================================================

* You may choose which license applies to you:

*

* - If you're using this work with Open Source databases, you may choose

*   either ASL or jOOQ License.

* - If you're using this work with at least one commercial database, you must

*   choose jOOQ License

*

* For more information, please visit http://www.jooq.org/licenses

*

* Apache Software License 2.0:

* -----------------------------------------------------------------------------

* Licensed under the Apache License, Version 2.0 (the "License");

* you may not use this file except in compliance with the License.

* You may obtain a copy of the License at

*

*  http://www.apache.org/licenses/LICENSE-2.0

*

* Unless required by applicable law or agreed to in writing, software

* distributed under the License is distributed on an "AS IS" BASIS,

* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

* See the License for the specific language governing permissions and

* limitations under the License.

*

* jOOQ License and Maintenance Agreement:

* -----------------------------------------------------------------------------

* Data Geekery grants the Customer the non-exclusive, timely limited and

* non-transferable license to install and use the Software under the terms of

* the jOOQ License and Maintenance Agreement.

*

* This library is distributed with a LIMITED WARRANTY. See the jOOQ License

* and Maintenance Agreement for more details: http://www.jooq.org/licensing

*/

* A default implementation for {@link DSLContext}.

* <p>

* You may use this as a base implementation for custom {@link DSLContext}

* subtypes preventing potential API breakage when upgrading jOOQ, or to

* delegate DSL method calls to your custom implementations.

*

* @author Lukas Eder

*/

    /**

     * Generated UID

     */

    private static final long       serialVersionUID = 2681360188806309513L;

    private static final JooqLogger log              = JooqLogger.getLogger(DefaultDSLContext.class);

    // -------------------------------------------------------------------------

    // XXX Constructors

    // -------------------------------------------------------------------------

    public DefaultDSLContext(SQLDialect dialect) {

        this(dialect, null);

    }

    public DefaultDSLContext(SQLDialect dialect, Settings settings) {

        this(new DefaultConfiguration(new NoConnectionProvider(), null, null, null, null, null, dialect, settings, null));

    }

    public DefaultDSLContext(Connection connection, SQLDialect dialect) {

        this(connection, dialect, null);

    }

    public DefaultDSLContext(Connection connection, SQLDialect dialect, Settings settings) {

        this(new DefaultConfiguration(new DefaultConnectionProvider(connection), null, null, null, null, null, dialect, settings, null));

    }

    public DefaultDSLContext(DataSource datasource, SQLDialect dialect) {

        this(datasource, dialect, null);

    }

    public DefaultDSLContext(DataSource datasource, SQLDialect dialect, Settings settings) {

        this(new DefaultConfiguration(new DataSourceConnectionProvider(datasource), null, null, null, null, null, dialect, settings, null));

    }

    public DefaultDSLContext(ConnectionProvider connectionProvider, SQLDialect dialect) {

        this(connectionProvider, dialect, null);

    }

    public DefaultDSLContext(ConnectionProvider connectionProvider, SQLDialect dialect, Settings settings) {

        this(new DefaultConfiguration(connectionProvider, null, null, null, null, null, dialect, settings, null));

    }

    public DefaultDSLContext(Configuration configuration) {

        super(configuration);

    }

    // -------------------------------------------------------------------------

    // XXX Configuration API

    // -------------------------------------------------------------------------

    @Override

    public Schema map(Schema schema) {

        return Utils.getMappedSchema(configuration(), schema);

    }

    @Override

    public <R extends Record> Table<R> map(Table<R> table) {

        return Utils.getMappedTable(configuration(), table);

    }

    // -------------------------------------------------------------------------

    // XXX Convenience methods accessing the underlying Connection

    // -------------------------------------------------------------------------

    @Override

    public Meta meta() {

        return new MetaImpl(configuration());

    }

    // -------------------------------------------------------------------------

    // XXX Transaction API

    // -------------------------------------------------------------------------

    @Override

    public <T> T transactionResult(TransactionalCallable<T> transactional) {

        T result = null;

        DefaultTransactionContext ctx = new DefaultTransactionContext(configuration().derive());

        TransactionProvider provider = ctx.configuration().transactionProvider();

        try {

            provider.begin(ctx);

            result = transactional.run(ctx.configuration());

            provider.commit(ctx);

        }

        catch (Exception cause) {

            try {

                provider.rollback(ctx.cause(cause));

            }

            // [#3718] Use reflection to support also JDBC 4.0

            catch (Exception suppress) {

                try {

                    Reflect.on(cause).call("addSuppressed", suppress);

                }

                catch (ReflectException ignore) {

                    log.error("Error when rolling back", suppress);

                }

            }

            if (cause instanceof RuntimeException) {

                throw (RuntimeException) cause;

            }

            else {

                throw new DataAccessException("Rollback caused", cause);

            }

        }

        return result;

    }

    @Override

    public void transaction(final TransactionalRunnable transactional) {

        transactionResult(new TransactionalCallable<Void>() {

            @Override

            public Void run(Configuration c) throws Exception {

                transactional.run(c);

                return null;

            }

        });

    }

    // -------------------------------------------------------------------------

    // XXX RenderContext and BindContext accessors

    // -------------------------------------------------------------------------

    @Override

    public RenderContext renderContext() {

        return new DefaultRenderContext(configuration());

    }

    @Override

    public String render(QueryPart part) {

        return renderContext().render(part);

    }

    @Override

    public String renderNamedParams(QueryPart part) {

        return renderContext().paramType(NAMED).render(part);

    }

    @Override

    public String renderNamedOrInlinedParams(QueryPart part) {

        return renderContext().paramType(NAMED_OR_INLINED).render(part);

    }

    @Override

    public String renderInlined(QueryPart part) {

        return renderContext().paramType(INLINED).render(part);

    }

    @Override

    public List<Object> extractBindValues(QueryPart part) {

        List<Object> result = new ArrayList<Object>();

        for (Param<?> param : extractParams0(part, false).values()) {

            result.add(param.getValue());

        }

        return Collections.unmodifiableList(result);

    }

    @Override

    public Map<String, Param<?>> extractParams(QueryPart part) {

        return extractParams0(part, true);

    }

    final Map<String, Param<?>> extractParams0(QueryPart part, boolean includeInlinedParams) {

        ParamCollector collector = new ParamCollector(configuration(), includeInlinedParams);

        collector.visit(part);

        return Collections.unmodifiableMap(collector.result);

    }

    @Override

    public Param<?> extractParam(QueryPart part, String name) {

        return extractParams(part).get(name);

    }

    @Override

    public BindContext bindContext(PreparedStatement stmt) {

        return new DefaultBindContext(configuration(), stmt);

    }

    @Override

    @Deprecated

    public int bind(QueryPart part, PreparedStatement stmt) {

        return bindContext(stmt).visit(part).peekIndex();

    }

    // -------------------------------------------------------------------------

    // XXX Attachable and Serializable API

    // -------------------------------------------------------------------------

    @Override

    public void attach(Attachable... attachables) {

        attach(Arrays.asList(attachables));

    }

    @Override

    public void attach(Collection<? extends Attachable> attachables) {

        for (Attachable attachable : attachables) {

            attachable.attach(configuration());

        }

    }

    // -------------------------------------------------------------------------

    // XXX Access to the loader API

    // -------------------------------------------------------------------------

    @Override

    public <R extends TableRecord<R>> LoaderOptionsStep<R> loadInto(Table<R> table) {

        return new LoaderImpl<R>(configuration(), table);

    }

    // -------------------------------------------------------------------------

    // XXX Plain SQL API

    // -------------------------------------------------------------------------

    @Override

    public Query query(String sql) {

        return query(template(sql), new Object[0]);

    }

    @Override

    public Query query(String sql, Object... bindings) {

        return query(template(sql), bindings);

    }

    @Override

    public Query query(String sql, QueryPart... parts) {

        return query(template(sql), (Object[]) parts);

    }

    @SuppressWarnings("deprecation")

    Query query(org.jooq.Template template, Object... parameters) {

        return new SQLQuery(configuration(), queryPart(template, parameters));

    }

    @Override

    public Result<Record> fetch(String sql) {

        return resultQuery(sql).fetch();

    }

    @Override

    public Result<Record> fetch(String sql, Object... bindings) {

        return resultQuery(sql, bindings).fetch();

    }

    @Override

    public Result<Record> fetch(String sql, QueryPart... parts) {

        return resultQuery(sql, parts).fetch();

    }

    @SuppressWarnings("deprecation")

    Result<Record> fetch(org.jooq.Template template, Object... parameters) {

        return resultQuery(template, parameters).fetch();

    }

    @Override

    public Cursor<Record> fetchLazy(String sql) {

        return resultQuery(sql).fetchLazy();

    }

    @Override

    public Cursor<Record> fetchLazy(String sql, Object... bindings) {

        return resultQuery(sql, bindings).fetchLazy();

    }

    @Override

    public Cursor<Record> fetchLazy(String sql, QueryPart... parts) {

        return resultQuery(sql, parts).fetchLazy();

    }

    @SuppressWarnings("deprecation")

    Cursor<Record> fetchLazy(org.jooq.Template template, Object... parameters) {

        return resultQuery(template, parameters).fetchLazy();

    }

    @Override

    public List<Result<Record>> fetchMany(String sql) {

        return resultQuery(sql).fetchMany();

    }

    @Override

    public List<Result<Record>> fetchMany(String sql, Object... bindings) {

        return resultQuery(sql, bindings).fetchMany();

    }

    @Override

    public List<Result<Record>> fetchMany(String sql, QueryPart... parts) {

        return resultQuery(sql, parts).fetchMany();

    }

    @SuppressWarnings("deprecation")

    List<Result<Record>> fetchMany(org.jooq.Template template, Object... parameters) {

        return resultQuery(template, parameters).fetchMany();

    }

    @Override

    public Record fetchOne(String sql) {

        return resultQuery(sql).fetchOne();

    }

    @Override

    public Record fetchOne(String sql, Object... bindings) {

        return resultQuery(sql, bindings).fetchOne();

    }

    @Override

    public Record fetchOne(String sql, QueryPart... parts) {

        return resultQuery(sql, parts).fetchOne();

    }

    @SuppressWarnings("deprecation")

    Record fetchOne(org.jooq.Template template, Object... parameters) {

        return resultQuery(template, parameters).fetchOne();

    }

    @Override

    public Object fetchValue(String sql) {

        return fetchValue((ResultQuery) resultQuery(sql));

    }

    @Override

    public Object fetchValue(String sql, Object... bindings) {

        return fetchValue((ResultQuery) resultQuery(sql, bindings));

    }

    @Override

    public Object fetchValue(String sql, QueryPart... parts) {

        return fetchValue((ResultQuery) resultQuery(sql, parts));

    }

    @Override

    public List<?> fetchValues(String sql) {

        return fetchValues((ResultQuery) resultQuery(sql));

    }

    @Override

    public List<?> fetchValues(String sql, Object... bindings) {

        return fetchValues((ResultQuery) resultQuery(sql, bindings));

    }

    @Override

    public List<?> fetchValues(String sql, QueryPart... parts) {

        return fetchValues((ResultQuery) resultQuery(sql, parts));

    }

    @Override

    public int execute(String sql) {

        return query(sql).execute();

    }

    @Override

    public int execute(String sql, Object... bindings) {

        return query(sql, bindings).execute();

    }

    @Override

    public int execute(String sql, QueryPart... parts) {

        return query(sql, parts).execute();

    }

    @SuppressWarnings("deprecation")

    int execute(org.jooq.Template template, Object... parameters) {

        return query(template, parameters).execute();

    }

    @Override

    public ResultQuery<Record> resultQuery(String sql) {

        return resultQuery(template(sql), new Object[0]);

    }

    @Override

    public ResultQuery<Record> resultQuery(String sql, Object... bindings) {

        return resultQuery(template(sql), bindings);

    }

    @Override

    public ResultQuery<Record> resultQuery(String sql, QueryPart... parts) {

        return resultQuery(template(sql), (Object[]) parts);

    }

    @SuppressWarnings("deprecation")

    ResultQuery<Record> resultQuery(org.jooq.Template template, Object... parameters) {

        return new SQLResultQuery(configuration(), queryPart(template, parameters));

    }

    // -------------------------------------------------------------------------

    // XXX JDBC convenience methods

    // -------------------------------------------------------------------------

    @Override

    public Result<Record> fetch(ResultSet rs) {

        return fetchLazy(rs).fetch();

    }

    @Override

    public Result<Record> fetch(ResultSet rs, Field<?>... fields) {

        return fetchLazy(rs, fields).fetch();

    }

    @Override

    public Result<Record> fetch(ResultSet rs, DataType<?>... types) {

        return fetchLazy(rs, types).fetch();

    }

    @Override

    public Result<Record> fetch(ResultSet rs, Class<?>... types) {

        return fetchLazy(rs, types).fetch();

    }

    @Override

    public Record fetchOne(ResultSet rs) {

        return Utils.fetchOne(fetchLazy(rs));

    }

    @Override

    public Record fetchOne(ResultSet rs, Field<?>... fields) {

        return Utils.fetchOne(fetchLazy(rs, fields));

    }

    @Override

    public Record fetchOne(ResultSet rs, DataType<?>... types) {

        return Utils.fetchOne(fetchLazy(rs, types));

    }

    @Override

    public Record fetchOne(ResultSet rs, Class<?>... types) {

        return Utils.fetchOne(fetchLazy(rs, types));

    }

    @Override

    public Object fetchValue(ResultSet rs) {

        return value1((Record1) fetchOne(rs));

    }

    @Override

    public <T> T fetchValue(ResultSet rs, Field<T> field) {

        return (T) value1((Record1) fetchOne(rs, field));

    }

    @Override

    public <T> T fetchValue(ResultSet rs, DataType<T> type) {

        return (T) value1((Record1) fetchOne(rs, type));

    }

    @Override

    public <T> T fetchValue(ResultSet rs, Class<T> type) {

        return (T) value1((Record1) fetchOne(rs, type));

    }

    @Override

    public List<?> fetchValues(ResultSet rs) {

        return fetch(rs).getValues(0);

    }

    @Override

    public <T> List<T> fetchValues(ResultSet rs, Field<T> field) {

        return fetch(rs).getValues(field);

    }

    @Override

    public <T> List<T> fetchValues(ResultSet rs, DataType<T> type) {

        return fetch(rs).getValues(0, type.getType());

    }

    @Override

    public <T> List<T> fetchValues(ResultSet rs, Class<T> type) {

        return fetch(rs).getValues(0, type);

    }

    @Override

    public Cursor<Record> fetchLazy(ResultSet rs) {

        try {

            return fetchLazy(rs, new MetaDataFieldProvider(configuration(), rs.getMetaData()).getFields());

        }

        catch (SQLException e) {

            throw new DataAccessException("Error while accessing ResultSet meta data", e);

        }

    }

    @Override

    public Cursor<Record> fetchLazy(ResultSet rs, Field<?>... fields) {

        ExecuteContext ctx = new DefaultExecuteContext(configuration());

        ExecuteListener listener = new ExecuteListeners(ctx);

        ctx.resultSet(rs);

        return new CursorImpl<Record>(ctx, listener, fields, null, false, true);

    }

    @Override

    public Cursor<Record> fetchLazy(ResultSet rs, DataType<?>... types) {

        try {

            Field<?>[] fields = new Field[types.length];

            ResultSetMetaData meta = rs.getMetaData();

            int columns = meta.getColumnCount();

            for (int i = 0; i < types.length && i < columns; i++) {

                fields[i] = field(meta.getColumnLabel(i + 1), types[i]);

            }

            return fetchLazy(rs, fields);

        }

        catch (SQLException e) {

            throw new DataAccessException("Error while accessing ResultSet meta data", e);

        }

    }

    @Override

    public Cursor<Record> fetchLazy(ResultSet rs, Class<?>... types) {

        return fetchLazy(rs, Utils.dataTypes(types));

    }

    @Override

    public Result<Record> fetchFromTXT(String string) {

        return fetchFromTXT(string, "{null}");

    }

    @Override

    public Result<Record> fetchFromTXT(String string, String nullLiteral) {

        return fetchFromStringData(Utils.parseTXT(string, nullLiteral));

    }

    @Override

    public Result<Record> fetchFromCSV(String string) {

        return fetchFromCSV(string, ',');

    }

    @Override

    public Result<Record> fetchFromCSV(String string, char delimiter) {

        CSVReader reader = new CSVReader(new StringReader(string), delimiter);

        List<String[]> data = null;

        try {

            data = reader.readAll();

        }

        catch (IOException e) {

            throw new DataAccessException("Could not read the CSV string", e);

        }

        finally {

            try {

                reader.close();

            }

            catch (IOException ignore) {}

        }

        return fetchFromStringData(data);

    }

    @Override

    public Result<Record> fetchFromJSON(String string) {

        List<String[]> data = new LinkedList<String[]>();

        JSONReader reader = null;

        try {

            reader = new JSONReader(new StringReader(string));

            List<String[]> records = reader.readAll();

            String[] fields = reader.getFields();

            data.add(fields);

            data.addAll(records);

        }

        catch (IOException e) {

            throw new DataAccessException("Could not read the JSON string", e);

        }

        finally {

            try {

                if (reader != null) {

                    reader.close();

                }

            }

            catch (IOException ignore) {}

        }

        return fetchFromStringData(data);

    }

    @Override

    public Result<Record> fetchFromStringData(String[]... data) {

        return fetchFromStringData(list(data));

    }

    @Override

    public Result<Record> fetchFromStringData(List<String[]> data) {

        if (data.size() == 0) {

            return new ResultImpl<Record>(configuration());

        }

        else {

            List<Field<?>> fields = new ArrayList<Field<?>>();

            for (String name : data.get(0)) {

                fields.add(fieldByName(String.class, name));

            }

            Result<Record> result = new ResultImpl<Record>(configuration(), fields);

            if (data.size() > 1) {

                for (String[] values : data.subList(1, data.size())) {

                    RecordImpl record = new RecordImpl(fields);

                    for (int i = 0; i < Math.min(values.length, fields.size()); i++) {

                        record.values[i] = values[i];

                        record.originals[i] = values[i];

                    }

                    result.add(record);

                }

            }

            return result;

        }

    }

    // -------------------------------------------------------------------------

    // XXX Global Query factory

    // -------------------------------------------------------------------------

    @Override