UNION

UNION

SELECT 1 AS idx UNION ALL SELECT 2 UNION ALL SELECT 3

autoincrement

val id: Column<Long> = long("id").autoIncrement("users_seq")

override val primaryKey: PrimaryKey = PrimaryKey(id)

com.microsoft.sqlserver.jdbc.SQLServerException: Cannot insert the value NULL into column 'id', table ''; column does not allow nulls. INSERT fails.

varbinary(max)

val image = binary("image", Int.MAX_VALUE).nullable()

Implicit conversion from data type nvarchar to varbinary(max) is not allowed. Use the CONVERT function to run this query.

Feb 13, 2021 5:28:37 PM com.impossibl.postgres.jdbc.ThreadedHousekeeper$HousekeeperReference cleanup
WARNING: Cleaning up leaked result-set
Allocation occurred @
  at org.jetbrains.exposed.sql.statements.jdbc.JdbcPreparedStatementImpl.executeQuery(JdbcPreparedStatementImpl.kt:21)
  at org.jetbrains.exposed.sql.Query.executeInternal(Query.kt:79)
  at org.jetbrains.exposed.sql.Query.executeInternal(Query.kt:15)
  at org.jetbrains.exposed.sql.statements.Statement.executeIn$exposed_core(Statement.kt:61)
  at org.jetbrains.exposed.sql.Transaction.exec(Transaction.kt:129)

fun getDBConn(): Database? {
    if (DBConnection == null) {
      synchronized(this) {
        if (DBConnection == null) {
          try {
            DBConnection = DataBaseConnection.connectWithDb(
              Config.DB_URL,
              Config.DB_DRIVER,
              Config.DB_USERNAME,
              Config.DB_PASSWORD
            )
          } catch (e: Exception) {
            println("error while connecting to db $e")
            return null
          }
        }
      }
    }
    return DBConnection
  }

timestamptz

timstamp(...)

Column<Instant>

2021-02-14 15:06:07.66052+00

2021-02-14 16:06:07.66052+01

Entity#new

INSERT IGNORE INTO

INSERT INTO

Database.connect(
    url = "jdbc:sqlite::memory:",
    driver = "org.sqlite.JDBC"
)

TransactionManager.manager.defaultIsolationLevel = Connection.TRANSACTION_SERIALIZABLE

Database.connect(“jdbc:sqlite:file:test?mode=memory&cache=shared”, “org.sqlite.JDBC”)

LocalDate

JavaLocalDateColumnType

LocalDate

JavaLocalDateColumnType

LocalDate

java.sql.Date

LocalDate

1991-01-01

1990-12-31

LocalDate

Join

Join.joinParts

java.util.NoSuchElementException: List is empty.

var statement: InsertStatement<Number>? = null
        var addOnStatement: List<ResultRow>?
        var foodSizeStatement: List<ResultRow>?
        var foodAddOns = emptyList<com.df.backend.model.FoodAddOn>()
        var foodSizes = emptyList<com.df.backend.model.FoodSize>()

        dbQuery {
            statement = Foods.insert { food ->
                food[name] = foodRequest.name
                food[description] = foodRequest.description
                food[category] = foodRequest.category
                food[foodImage] = foodRequest.foodImage
                food[createdAt] = foodRequest.createdAt
                food[updatedAt] = foodRequest.updatedAt
            }

            val resultRow = statement?.resultedValues?.get(0)
            println("Food count ${statement?.resultedValues?.size}")
            println("Addon List ${foodRequest.foodAddOns.size}")

            addOnStatement = FoodAddOn.batchInsert(foodRequest.foodAddOns) { addOn ->
                this[FoodAddOn.name] = addOn.name
                this[FoodAddOn.addOnPrice] = addOn.addOnPrice
                this[FoodAddOn.foodAddOnImage] = addOn.foodAddOnImage
                this[FoodAddOn.foodId] = resultRow?.get(Foods.foodId)!!
            }

            foodAddOns = rowToAddOns(addOnStatement!!)

            foodSizeStatement = FoodSize.batchInsert(foodRequest.foodSizes) { foodSize ->
                this[FoodSize.size] = foodSize.size
                this[FoodSize.sizePrice] = foodSize.sizePrice.toInt()
                this[FoodSize.foodId] = resultRow?.get(Foods.foodId)!!
            }

            foodSizes = rowToSizes(foodSizeStatement!!)
        }
        return rowToFood(statement?.resultedValues?.get(0),foodAddOns, foodSizes )

IllegalStateException: No transaction in context

val breakdownDimensions = transaction {
                Dimension.find {
                    Dimensions.id inList breakdownIds
                }
            }

            for (dimension in breakdownDimensions) {
                println(dimension.id)
            }

SchemaUtils

createStatements

val agents: ObservableList<AgentModel> by lazy {
        transaction(db) {
            addLogger(StdOutSqlLogger)
            AgentEntity.all().map {
                AgentModel().apply {
                    item = it
                }
            }.toObservable()
        }
    }