• Home
• org.jaxdb
• jsql
• 0.5.1
• source code
• Command.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

org.jaxdb.jsql.Command Maven / Gradle / Ivy

/* Copyright (c) 2021 JAX-DB
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * You should have received a copy of The MIT License (MIT) along with this
 * program. If not, see .
 */

package org.jaxdb.jsql;

import static org.libj.lang.Assertions.*;

import java.io.Closeable;
import java.io.IOException;
import java.math.BigDecimal;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.UUID;

import org.jaxdb.jsql.Callbacks.OnCommit;
import org.jaxdb.jsql.Callbacks.OnExecute;
import org.jaxdb.jsql.Callbacks.OnNotify;
import org.jaxdb.jsql.Callbacks.OnRollback;
import org.jaxdb.jsql.keyword.Case;
import org.jaxdb.jsql.keyword.Delete.DELETE;
import org.jaxdb.jsql.keyword.Delete._DELETE;
import org.jaxdb.jsql.keyword.Insert.INSERT;
import org.jaxdb.jsql.keyword.Insert._INSERT;
import org.jaxdb.jsql.keyword.Keyword;
import org.jaxdb.jsql.keyword.Update.SET;
import org.jaxdb.jsql.keyword.Update.UPDATE;
import org.jaxdb.vendor.DbVendor;
import org.libj.lang.Throwables;
import org.libj.lang.UUIDs;
import org.libj.sql.AuditConnection;
import org.libj.sql.AuditStatement;
import org.libj.sql.ResultSets;
import org.libj.sql.exception.SQLExceptions;
import org.libj.util.ArrayUtil;
import org.libj.util.function.ToBooleanFunction;

abstract class Command extends Keyword implements Closeable {
  @SuppressWarnings("unchecked")
  public final E onExecute(final OnExecute onExecute) {
    getCallbacks().addOnExecute(onExecute);
    return (E)this;
  }

  private boolean closed;
  Callbacks callbacks;

  Callbacks getCallbacks() {
    return callbacks == null ? callbacks = new Callbacks() : callbacks;
  }

  void assertNotClosed() {
    if (closed)
      throw new IllegalStateException("statement is closed");
  }

  @Override
  public void close() {
    closed = true;
  }

  abstract static class Modification extends Command {
    data.Table entity;

    private Modification(final data.Table entity) {
      this.entity = entity;
    }

    final void revertEntity() {
      if (entity != null)
        entity.revert();
    }

    @Override
    public final void close() {
      super.close();
      if (entity != null)
        entity._commitEntity$();
    }

    String sessionId;

    @SuppressWarnings("unchecked")
    public final C onCommit(final OnCommit onCommit) {
      getCallbacks().addOnCommit(onCommit);
      return (C)this;
    }

    @SuppressWarnings("unchecked")
    public final R onRollback(final OnRollback onRollback) {
      getCallbacks().addOnRollback(onRollback);
      return (R)this;
    }
  }

  private static final data.Column[] emptyColumns = {};

  private static data.Column[] recurseColumns(final data.Column[] columns, final ToBooleanFunction> predicate, final int length, final int index, final int depth) {
    if (index == length)
      return depth == 0 ? emptyColumns : new data.Column[depth];

    final data.Column column = columns[index];
    final boolean include = predicate.applyAsBoolean(column);
    if (!include)
      return recurseColumns(columns, predicate, length, index + 1, depth);

    final data.Column[] results = recurseColumns(columns, predicate, length, index + 1, depth + 1);
    results[depth] = column;
    return results;
  }

  static final class Insert extends Command.Modification implements _INSERT, keyword.Insert.CONFLICT_ACTION_NOTIFY, keyword.Insert.ON_CONFLICT {
    private data.Column[] columns;
    private data.Column[] primaries;
    final data.Column[] autos;
    private keyword.Select.untyped.SELECT select;
    private boolean isOnConflict;
    private data.Column[] onConflictColumns;
    private boolean doUpdate;

    Insert(final data.Table entity) {
      super(entity);
      this.columns = null;
      this.autos = recurseColumns(entity._auto$, c -> c.setByCur != data.Column.SetBy.USER, entity._auto$.length, 0, 0);
    }

    Insert(final data.Column column, final data.Column[] columns) {
      super(null);
      this.columns = ArrayUtil.splice(columns, 0, 0, column);
      final data.Table table = this.columns[0].getTable();
      for (int i = 1, i$ = this.columns.length; i < i$; ++i) // [A]
        if (!this.columns[i].getTable().equals(table))
          throw new IllegalArgumentException("All columns must belong to the same Table");

      this.primaries = recurseColumns(this.columns, c -> c.primaryIndexType != null, this.columns.length, 0, 0);
      this.autos = recurseColumns(this.columns, c -> c.setByCur != data.Column.SetBy.USER && c.generateOnInsert == GenerateOn.AUTO_GENERATED, this.columns.length, 0, 0);
    }

    @Override
    public keyword.Insert.CONFLICT_ACTION_NOTIFY onNotify(final OnNotify onNotify) {
      if (sessionId == null)
        sessionId = UUIDs.toString32(UUID.randomUUID());

      getCallbacks().addOnNotify(sessionId, onNotify);
      return this;
    }

    @Override
    public keyword.Insert.CONFLICT_ACTION_NOTIFY onNotify(final boolean onNotify) {
      if (sessionId == null)
        sessionId = UUIDs.toString32(UUID.randomUUID());

      getCallbacks().addOnNotify(sessionId, onNotify);
      return this;
    }

    @Override
    public INSERT VALUES(final keyword.Select.untyped.SELECT select) {
      this.select = select;
      return this;
    }

    @Override
    public keyword.Insert.ON_CONFLICT ON_CONFLICT() {
      isOnConflict = true;
      if (entity != null)
        onConflictColumns = entity._primary$;
      else if (primaries != null)
        onConflictColumns = primaries;

      return this;
    }

    @Override
    public keyword.Insert.CONFLICT_ACTION DO_UPDATE() {
      doUpdate = true;
      return this;
    }

    @Override
    public keyword.Insert.CONFLICT_ACTION DO_NOTHING() {
      doUpdate = false;
      return this;
    }

    @Override
    final data.Table getTable() {
      if (entity != null)
        return entity;

      if (columns != null)
        return entity = columns[0].getTable();

      throw new UnsupportedOperationException("Expected insert.entities != null || insert.select != null");
    }

    @Override
    final data.Column getColumn() {
      throw new UnsupportedOperationException();
    }

    @Override
    void compile(final Compilation compilation, final boolean isExpression) throws IOException, SQLException {
      final data.Column[] columns = this.columns != null ? this.columns : entity._column$;
      final Compiler compiler = compilation.compiler;
      if (isOnConflict)
        compiler.compileInsertOnConflict(columns, select, onConflictColumns, doUpdate, compilation);
      else if (select != null)
        compiler.compileInsertSelect(columns, select, false, compilation);
      else
        compiler.compileInsert(columns, false, compilation);
    }
  }

  static final class Update extends Command.Modification implements SET, keyword.Update.UPDATE_NOTIFY {
    private ArrayList sets;
    private Condition where;

    Update(final data.Table entity) {
      super(entity);
    }

    @Override
    public keyword.Update.UPDATE_NOTIFY onNotify(final OnNotify onNotify) {
      if (sessionId == null)
        sessionId = UUIDs.toString32(UUID.randomUUID());

      getCallbacks().addOnNotify(sessionId, onNotify);
      return this;
    }

    @Override
    public keyword.Update.UPDATE_NOTIFY onNotify(final boolean onNotify) {
      if (sessionId == null)
        sessionId = UUIDs.toString32(UUID.randomUUID());

      getCallbacks().addOnNotify(sessionId, onNotify);
      return this;
    }

    private void initSets() {
      if (sets == null)
        sets = new ArrayList<>();
    }

    @Override
    public SET SET(final data.Column column, final type.Column to) {
      initSets();
      sets.add(column);
      sets.add((Subject)to);
      return this;
    }

    @Override
    public SET SET(final data.Column column, final T to) {
      initSets();
      sets.add(column);
      // FIXME: data.ENUM.NULL
      sets.add(to == null ? null : data.wrap(to));
      return this;
    }

    @Override
    public UPDATE WHERE(final Condition condition) {
      this.where = condition;
      return this;
    }

    @Override
    final data.Table getTable() {
      return entity;
    }

    @Override
    final data.Column getColumn() {
      throw new UnsupportedOperationException();
    }

    @Override
    final void compile(final Compilation compilation, final boolean isExpression) throws IOException, SQLException {
      final Compiler compiler = compilation.compiler;
      if (sets != null)
        compiler.compileUpdate(entity, sets, where, compilation);
      else
        compiler.compileUpdate(entity, compilation);
    }
  }

  static final class Delete extends Command.Modification implements _DELETE, keyword.Delete.DELETE_NOTIFY {
    private Condition where;

    Delete(final data.Table entity) {
      super(entity);
    }

    @Override
    public keyword.Delete.DELETE_NOTIFY onNotify(final OnNotify onNotify) {
      if (sessionId == null)
        sessionId = UUIDs.toString32(UUID.randomUUID());

      getCallbacks().addOnNotify(sessionId, onNotify);
      return this;
    }

    @Override
    public keyword.Delete.DELETE_NOTIFY onNotify(final boolean onNotify) {
      if (sessionId == null)
        sessionId = UUIDs.toString32(UUID.randomUUID());

      getCallbacks().addOnNotify(sessionId, onNotify);
      return this;
    }

    @Override
    public DELETE WHERE(final Condition where) {
      this.where = where;
      return this;
    }

    @Override
    final data.Table getTable() {
      return entity;
    }

    @Override
    final data.Column getColumn() {
      return where;
    }

    @Override
    void compile(final Compilation compilation, final boolean isExpression) throws IOException, SQLException {
      final Compiler compiler = compilation.compiler;
      if (where != null)
        compiler.compileDelete(entity, where, compilation);
      else
        compiler.compileDelete(entity, compilation);
    }
  }

  static final class Select {
    public static class untyped {
      abstract static class SELECT extends Command> implements keyword.Select.untyped._SELECT, keyword.Select.untyped.FROM, keyword.Select.untyped.GROUP_BY, keyword.Select.untyped.HAVING, keyword.Select.untyped.UNION, keyword.Select.untyped.JOIN, keyword.Select.untyped.ADV_JOIN, keyword.Select.untyped.ON, keyword.Select.untyped.ORDER_BY, keyword.Select.untyped.LIMIT, keyword.Select.untyped.OFFSET, keyword.Select.untyped.FOR, keyword.Select.untyped.NOWAIT, keyword.Select.untyped.SKIP_LOCKED, keyword.Select.untyped.WHERE {
        enum LockStrength {
          SHARE,
          UPDATE
        }

        enum LockOption {
          NOWAIT("NOWAIT"),
          SKIP_LOCKED("SKIP LOCKED");

          private final String name;

          private LockOption(final String name) {
            this.name = name;
          }

          @Override
          public String toString() {
            return name;
          }
        }

        enum JoinKind {
          INNER(""),
          CROSS(" CROSS"),
          NATURAL(" NATURAL"),
          LEFT(" LEFT OUTER"),
          RIGHT(" RIGHT OUTER"),
          FULL(" FULL OUTER");

          private final String keyword;

          private JoinKind(final String keyword) {
            this.keyword = keyword;
          }

          @Override
          public String toString() {
            return keyword;
          }
        }

        private boolean tableCalled;
        private data.Table table;

        final boolean distinct;
        final type.Entity[] entities;

        private boolean fromCalled;
        private data.Table[] from;

        ArrayList