text stringlengths 14 100k | source stringclasses 1
value | repo stringclasses 810
values | language stringclasses 13
values |
|---|---|---|---|
<|fim_prefix|>package io.getquill.norm.capture
import io.getquill.ast.Query
import io.get<|fim_suffix|>Conflict(q, false, traceConfig))(traceConfig)
}
<|fim_middle|>quill.util.TraceConfig
object AvoidCapture {
def apply(q: Query, traceConfig: TraceConfig): Query =
Dealias(AvoidAlias<|endoftext|> | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.norm.capture
import io.getquill.ast._
import io.getquill.norm.BetaReduction
import io.getquill.util.{Interpolator, TraceConfig}
import io.getquill.util.Messages.TraceType
case class Dealias(state: Option[Ident], traceConfig: TraceConfig) extends StatefulTransformer[Option[Ident]] {
... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.norm.capture
import io.getquill.ast._
/**
* Walk through any Queries that a returning clause has and replace Ident of the
* returning variable with ExternalIdent so that in later steps involving filter
* simplification, it will not be mistakenly dealiased with a potential shadow.
... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.norm.capture
import io.getquill.ast.Ident
object TemporaryIdent {
def unapply(id: Ident) =
if (id.name.matches("\\[tmp_[0-<|fim_suffix|>
else
None
}
<|fim_middle|>9A-Za-z]+\\]"))
Some(id)<|endoftext|> | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.quat
import java.nio.ByteBuffer
import java.util.Base64
import boopickle.Default._
import scala.collection.mutable.LinkedHashMap
object BooQuatSerializer {
case class ProductWithRenames(data: LinkedHashMap[String, Quat], renames: List[(String, String)])
implicit object product... | fim | zio/zio-quill | scala |
package io.getquill.quat
import io.getquill.quat.FindBranches.BranchQuat.PathElement
import io.getquill.quat.FindBranches.Result
import io.getquill.quat.FindBranches.Result.ProductWithBranches
import scala.annotation.tailrec
object VerifyNoBranches {
private implicit final class DotsExt(private val list: List[Stri... | fim | zio/zio-quill | scala |
<|fim_suffix|>ble.LinkedHashMap(), tpe)
def apply(name: String, fields: Iterator[(String, Quat)]): Quat.Product =
new Quat.Product(name, mutable.LinkedHashMap[String, Quat]() ++ fields, mutable.LinkedHashMap(), Type.Concrete)
def apply(name: String, tpe: Type, fields: Iterator[(String, Quat)]): Quat.Prod... | fim | zio/zio-quill | scala |
<|fim_suffix|>elper {
def valueQuat(quat: Quat): Quat =
quat match {
case Quat.BooleanExpression => Quat.BooleanValue
case p @ Quat.Product(fields) => Quat.Product(p.name, fields.toList.map { case (k, v) => (k, valueQuat(v)) })
case other => other
}
def valuefyQuatInP... | fim | zio/zio-quill | scala |
package io.getquill.quat
import io.getquill.ast.Ast
import io.getquill.quotation.QuatException
private[getquill] object QuatOps {
object Implicits {
implicit final class QuatOpsExt(private val quat: Quat.Product) extends AnyVal {
def renameAtPath(path: List[String], renames: List[(String, String)]): Quat.... | fim | zio/zio-quill | scala |
<|fim_suffix|>se q @ OptionTableFlatMap(a, b, c) =>
(q, free(a, b, c))
case q @ OptionTableMap(a, b, c) =>
(q, free(a, b, c))
case q @ OptionTableExists(a, b, c) =>
(q, free(a, b, c))
case q @ OptionTableForall(a, b, c) =>
(q, free(a, b, c))
case q @ OptionFlatMap... | fim | zio/zio-quill | scala |
<|fim_suffix|>tion.message)
object NonQuotedException {
final val message = "The query definition must happen within a `quote` block."
def apply() = throw new NonQuotedException
}
<|fim_prefix|>package io.getqui<|fim_middle|>ll.quotation
class NonQuotedException extends Exception(NonQuotedExcep<|endoftext|> | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.quotation
import io.getquill.quat.Quat
class QuatException<|fim_suffix|>atException(${e.getMessage + (if (additionalMessage != "") ", " + additionalMessage else "")})"
}
}
}
<|fim_middle|>(message: String) extends IllegalArgumentException(message)
object QuatException {
de... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.sql
import io.getquill.ast.{Aggregation, Ast, CollectAst, Infix}
object Common {
object ContainsImpurities {
def unapply(ast: Ast) =
CollectAs<|fim_suffix|> inf: Infix if (!inf.pure) => inf
}.nonEmpty
}
}
<|fim_middle|>t(ast) {
case agg: Aggregation ... | fim | zio/zio-quill | scala |
<|fim_suffix|>, alias)
}
private def orderByCriteria(ast: Ast, ordering: Ast, from: List[FromContext]): List[OrderByCriteria] =
(ast, ordering) match {
case (Tuple(properties), ord: PropertyOrdering) => properties.flatMap(orderByCriteria(_, ord, from))
case (Tuple(properties), TupleOrdering(ord))... | fim | zio/zio-quill | scala |
<|fim_suffix|>zeBooleans
import io.getquill.util.Messages
import io.getquill.IdiomContext
trait BooleanLiteralSupport extends SqlIdiom {
override def normalizeAst(
ast: Ast,
concatBehavior: ConcatBehavior,
equalityBehavior: EqualityBehavior,
idiomContext: IdiomContext
) = {
val norm = SqlNorma... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.context.sql.idiom
import<|fim_suffix|>override def concatFunction = "UNNEST"
}
trait NoConcatSupport {
this: SqlIdiom =>
override def concatFunction = Messages.fail(s"`concatMap` not supported by ${this.getClass.getSimpleName}")
}
<|fim_middle|> io.getquill.util.Messages
trait ... | fim | zio/zio-quill | scala |
package io.getquill.context.sql.idiom
import io.getquill.ast._
import io.getquill.idiom.StatementInterpolator._
import io.getquill.idiom.Token
import io.getquill.NamingStrategy
import io.getquill.IdiomContext
import io.getquill.util.Messages.fail
trait OnConflictSupport {
self: SqlIdiom =>
implicit def conflictT... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.context.sql.idiom
trait PositionalB<|fim_suffix|>Placeholder(index: Int): String = s"$$${index + 1}"
}
<|fim_middle|>indVariables { self: SqlIdiom =>
override def lifting<|endoftext|> | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.context.sql.idiom
trait QuestionMarkBindVariables { self:<|fim_suffix|>qlIdiom =>
override def liftingPlaceholder(index: Int): String = s"?"
}
<|fim_middle|> S<|endoftext|> | fim | zio/zio-quill | scala |
<|fim_suffix|>))
import idiom._
implicit val stableTokenizer = idiom.astTokenizer(
new Tokenizer[Ast] {
override def token(v: Ast): Token = astTokenizer(this, strategy, idiomContext).token(v)
},
strategy,
idiomContext
)
def ` AS [alias]`(alias: Ident) =
useActionT... | fim | zio/zio-quill | scala |
package io.getquill.context.sql.idiom
import io.getquill.ast._
import io.getquill.context.sql._
import io.getquill.quotation.FreeVariables
import io.getquill.quat.Quat
case class Error(free: List[Ident], ast: Ast)
case class InvalidSqlQuery(errors: List[Error]) {
override def toString = {
val allVars = errors.... | fim | zio/zio-quill | scala |
<|fim_suffix|>er(a), applyInner(b), on)
case FlatJoinContext(t, a, on) => FlatJoinContext(t, applyInner(a), on)
case other => other
}
def apply(q: SqlQuery): SqlQuery =
q match {
case q: FlattenSqlQuery => q.copy(from = q.from.map(applyInner(_)))(q.quat)
... | fim | zio/zio-quill | scala |
<|fim_suffix|>inionated(_, _, _, Hidden))) =>
trace"ExpandDistinct Keep Distinct(Map(q, _, Property(Hidden)))" andReturn d
// This was a buggy clause that was not well typed. Not needed anymore since we have SheathLeafClauses
// In situations where a simple, single property is being dis... | fim | zio/zio-quill | scala |
<|fim_suffix|>ple(List(tA, bt)))
case q @ Join(t, a, b, tA, tB, on) =>
(Join(t, nestedExpand(a, tA), nestedExpand(b, tB), tA, tB, on), Tuple(List(tA, tB)))
}
private def nestedExpand(q: Ast, id: Ident) =
normalize(expand(q, Some(id))) match {
case Map(q, _, _) => q
case q ... | fim | zio/zio-quill | scala |
package io.getquill.context.sql.norm
import io.getquill.ast._
object ExpandMappedInfix {
def apply(q: Ast): Ast =
Transform(q) { case Map(Infix("" :: parts, (q: Query) :: params, pure, tr, quat), x, p) =>
Infix("" :: parts, Map(q, x, p) :: params, pure, tr, quat)
}
}
<|endoftext|> | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.context.sql.norm
import io.getquill.ast._
import io.getquill.context.sql._
import io.getquill.sql.norm.{InContext, QueryLevel, SelectPropertyProtractor, StatelessQueryTransformer}
import io.getquill.ast.PropertyOrCore
import io.getquill.norm.PropertyMatryoshka
import io.getquill.quat.... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.context.sql.norm
import io.getquill.ast.Aggregation
import io.getquill.ast.Ast
import io.getquill.ast.Drop
import io.getquill.ast.Filter
import io.getquill.ast.FlatMap
import io.getquill.ast.Ident
import io.getquill.ast.Join
import io.getquill.ast.Map
import io.getquill.ast.Query
impo... | fim | zio/zio-quill | scala |
<|fim_suffix|>apply(e: Action): Action =
e match {
case Update(Filter(query, alias, body), assignments) =>
val (newAlias, newBody) = hideAlias(alias, body)
Update(Filter(query, newAlias, newBody), assignments.map(hideAssignmentAlias(_)))
case Delete(Filter(query, alias, body)) =>
... | fim | zio/zio-quill | scala |
package io.getquill.sql.norm
import io.getquill.ast._
import io.getquill.norm.BetaReduction
object NormalizeFilteredActionAliases {
private[getquill] def chooseAlias(entityName: String, batchAlias: Option[String]) = {
val lowerEntityName = entityName.toLowerCase
val possibleEntityNameChar =
if (lowerE... | fim | zio/zio-quill | scala |
<|fim_suffix|>name where columns actually named _1,_2 become col_1,col_2)
// and then unless the proper alias is there (e.g. foo.col_1 AS _1, foo.col_2 AS _2) subsequent selects will incorrectly
// select _1.foo,_2.bar fields assuming the _1,_2 columns actually exist.
// However, in situations where the actual co... | fim | zio/zio-quill | scala |
<|fim_suffix|>attenSqlQuery(from, where, groupBy, orderBy, limit, offset, select, distinct) =>
Nil ++ newSelect.map(_.ast) ++ where ++ groupBy ++ orderBy.map(_.ast) ++ limit ++ offset
}
private def expandContext(s: FromContext, asts: List[Ast]): (FromContext, LinkedHashSet[Property]) =
s match {
... | fim | zio/zio-quill | scala |
<|fim_suffix|>ost entity of the quat. This is always visible since it is the actual column of the table
List((Property.Opinionated(core, name, isPropertyRenameable(name), Visible), List(name)))
}.toList
}
}
<|fim_prefix|>package io.getquill.sql.norm
import io.getquill.ast.{Ast, Core, Ident, Property, Ren... | fim | zio/zio-quill | scala |
<|fim_suffix|>ate(heading: String) =
((ast: Ast) => title(heading, TraceType.SqlNormalizations)(ast))
val ExpandJoinPhase = new ExpandJoin(NormalizePhase)
val RenamePropertiesPhase = new RenameProperties(traceConfig)
val ExpandDistinctPhase = new ExpandDistinct(traceConfig)
val Sh... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.sql.norm
import io.getquill.context.sql.{FlatJoinContext, FlattenSqlQuery, FromContext, InfixContext, JoinContext, TopInfixQuery, QueryContext, SetOperationSqlQuery, SqlQuery, TableContext, UnaryOperationSqlQuery}
import io.getquill.quat.Quat
sealed trait QueryLevel {
def isTop: Bo... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.sql.norm
import io.getquill.ast.Implicits.AstOpsExt
import io.getquill.ast.{BooleanOperator, _}
import io.getquill.quat.QuatOps.{HasBooleanQuat, HasBooleanValueQuat}
import io.getquill.quat.Quat.{BooleanExpression, BooleanValue}
object VendorizeBooleans extends StatelessTransformer {... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.context.sql.norm.nested
import io.getquill.PseudoAst
import io.getquill.context.sql.SelectValue
object Elements {
/**
* In order to be able to reconstruct the original ordering of elements inside
* of a select clause, we need to keep track of their order, not only within
... | fim | zio/zio-quill | scala |
<|fim_suffix|>st): Boolean =
CollectAst.byType[Infix](ast).nonEmpty
// build paths to every infix and see these paths were not selected already
def findMissingInfixes(ast: Ast, parentOrder: List[Int]): List[(Ast, List[Int])] = {
trace"Searching for infix: $ast in the sub-path $parentOrder".andLog()... | fim | zio/zio-quill | scala |
<|fim_suffix|>private val cache = mutable.Map.empty[K, Entry]
def getOrElseUpdate(key: K, value: => Option[V], ttl: Duration): Option[V] =
synchronized {
val now = System.currentTimeMillis
evict(now)
val expiration = now + ttl.toMillis
cache.get(key) match {
case Some(entry) =>
... | fim | zio/zio-quill | scala |
<|fim_suffix|>
list.flatMap { l =>
t.map(l :+ _)
}
}
}
<|fim_prefix|>package io.getquill.util
import scala.util.Try
object CollectTry {
def apply[T](list: List[Try[T]])<|fim_middle|>: Try[List[T]] =
list.foldLeft(Try(List.empty[T])) { case (list, t) =><|endoftext|> | fim | zio/zio-quill | scala |
package io.getquill.util
import com.typesafe.scalalogging.Logger
import org.slf4j.LoggerFactory
import scala.annotation.tailrec
class ContextLogger(name: String) {
val underlying: Logger = Logger(LoggerFactory.getLogger(name))
private def bindsEnabled = io.getquill.util.Messages.logBinds || underlying.underlyin... | fim | zio/zio-quill | scala |
<|fim_suffix|>ntains("\n")
def multiline(indent: Int, prefix: String): String =
str.split("\n").map(elem => indent.prefix + prefix + elem).mkString("\n")
}
implicit final class IndentOps(private val i: Int) extends AnyVal {
def prefix: String = indentOf(i)
}
private def indentOf(num: Int): Strin... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.util
import scala.annotation.tailrec
import scala.collection.mutable.ListBuffer
object Interleave {
def apply[T](l1: List[T], l2: List[T]): List[T] =
interleave(l1, l2, ListBuffer.empty)
@tailrec
private[this] def interleave[T](l1: List[T], l2: List[T], acc: ListBuffer[T]... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.util
import java.io.PrintStream
import io.getquill.AstPrinter
import io.getquill.AstPrinter.Implicits._
import io.getquill.util.Messages.TraceType
import io.getquill.util.IndentUtil._
import scala.collection.mutable
import scala.util.matching.Regex
case class TraceConfig(enabledTra... | fim | zio/zio-quill | scala |
<|fim_suffix|>
def apply(configPrefix: String) = {
val factory = ConfigFactory.load(getClass.getClassLoader)
if (factory.hasPath(configPrefix))
factory.getConfig(configPrefix)
else
ConfigFactory.empty
}
}
<|fim_prefix|>package io.getquill.util
import com.typesafe.config.ConfigFactory
objec... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.util
import io.getquill.AstPrinter
import scala.collection.mutable.{Map => MutableMap}
object Messages {
private def variable(propName: String, envName: String, default: String) =
Option(System.getProperty(propName)).orElse(sys.env.get(envName)).getOrElse(default)
def reset... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.util
object Show {
trait Show[T] {
def show(v: T): String
}
object Show {
// noinspection ConvertExpressionToSAM
def apply[T]<|fim_suffix|>
}
<|fim_middle|>(f: T => String): Show[T] =
new Show[T] {
def show(v: T): String = f(v)
}
}
implicit ... | fim | zio/zio-quill | scala |
<|fim_prefix|>/*
* Scala (https://www.scala-lang.org)
*
* Copyright EPFL and Lightbend, Inc.
*
* Licensed under Apache License 2.0
* (http://www.apache.org/licenses/LICENSE-2.0).
*
* See the NOTICE file distributed with this work for
* additional information regarding copyright ownership.
*/
package io.getqu... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill
import java.io.Closeable
import javax.sql.DataSource
import com.typesafe.config.Config
import io.getquill.context.jdbc.{JdbcContext, H2JdbcContex<|fim_suffix|>h Closeable)
extends JdbcContext[H2Dialect, N]
with H2JdbcContextBase[H2Dialect, N] {
override val idiom: H2Dialect... | fim | zio/zio-quill | scala |
<|fim_suffix|> source", ex)
}
}
<|fim_prefix|>package io.getquill
import com.typesafe.config.Config
import com.zaxxer.hikari.HikariConfig
import com.zaxxer.hikari.HikariDataSource
import java.util.Properties
import scala.util.control.NonFatal
case class JdbcContextConfig(config: Config) {
def configProperties... | fim | zio/zio-quill | scala |
package io.getquill
import java.io.Closeable
import javax.sql.DataSource
import com.typesafe.config.Config
import io.getquill.context.jdbc.{JdbcContext, MysqlJdbcContextBase}
import io.getquill.util.LoadConfig
class MysqlJdbcContext[+N <: NamingStrategy](val naming: N, dataSourceInput: => DataSource with Closeable)
... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill
import java.io.Closeable
import com.typesafe.config.Config
import io.getquill.context.jdbc.{JdbcContext, OracleJdbcContextBase}
import io.getquil<|fim_suffix|>[+N <: NamingStrategy](val naming: N, dataSourceInput: => DataSource with Closeable)
extends JdbcContext[OracleDialect, N... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill
import java.io.Closeable
import javax.sql.DataSource
import com.typesafe.config.Config
import io.getquill.context.jdbc<|fim_suffix|>override val idiom: PostgresDialect = PostgresDialect
override lazy val dataSource: DataSource with Closeable = dataSourceInput
... | fim | zio/zio-quill | scala |
package io.getquill
import java.io.Closeable
import javax.sql.DataSource
import com.typesafe.config.Config
import io.getquill.context.jdbc.{JdbcContext, SqlServerJdbcContextBase}
import io.getquill.util.LoadConfig
class SqlServerJdbcContext[+N <: NamingStrategy](val naming: N, dataSourceInput: => DataSource with Clo... | fim | zio/zio-quill | scala |
<|fim_suffix|>onfig: JdbcContextConfig) = this(naming, config.dataSource)
def this(naming: N, config: Config) = this(naming, JdbcContextConfig(config))
def this(naming: N, configPrefix: String) = this(naming, LoadConfig(configPrefix))
}
<|fim_prefix|>package io.getquill
import java.io.Closeable
import javax.sql.D... | fim | zio/zio-quill | scala |
<|fim_suffix|>s JDBC array decoder for type `T` which is already supported by
* database as array element.
*
* @param bf
* builder factory is needed to create instances of decoder's collection
* @tparam T
* element type
* @tparam Col
* seq type
* @return
* JDBC array decoder
*/
... | fim | zio/zio-quill | scala |
package io.getquill.context.jdbc
import java.sql.{Timestamp, Date => SqlDate}
import java.sql.Types._
import java.time.LocalDate
import java.util.Date
import io.getquill.context.sql.encoding.ArrayEncoding
import scala.collection.compat._
trait ArrayEncoders extends ArrayEncoding {
self: JdbcContextTypes[_, _] =>
... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.context.jdbc
import io.getquill._
trait PostgresJdbcContextBase[+D <: PostgresDialect, +N <: NamingStrategy]
extends PostgresJdbcTypes[D, N]
with JdbcContextBase[D, N]
trait H2JdbcContextBase[+D <: H2Dialect, +N <: NamingStrategy] extends H2JdbcTypes[D, N] with JdbcContextBa... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.context.jdbc
import java.sql.Types
trait BooleanIntEncoding<|fim_suffix|>sion) => row.getInt(index) == 1)
}
<|fim_middle|> {
this: JdbcContextTypes[_, _] =>
implicit val booleanEncoder: Encoder[Boolean] =
encoder(Types.TINYINT, (index, value, row) => row.setInt(index, if (va... | fim | zio/zio-quill | scala |
<|fim_suffix|>ncoder[Boolean] = encoder(Types.BOOLEAN, _.setBoolean)
implicit val booleanDecoder: Decoder[Boolean] = decoder(_.getBoolean)
}
<|fim_prefix|>package io.getquill.context.jdbc
import java.sql.Ty<|fim_middle|>pes
trait BooleanObjectEncoding {
this: JdbcContextTypes[_, _] =>
implicit val booleanEncod... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.context.jdbc
import java.sql.Types
import java.time.{Instant, LocalDate, LocalDateTime, LocalTime, OffsetDateTime, OffsetTime, ZoneOffset, ZonedDateTime}
import java.{time, util}
import java.util.{Calendar, TimeZone}
import scala.math.BigDecimal.javaBigDecimal2bigDecimal
trait Decode... | fim | zio/zio-quill | scala |
<|fim_suffix|>coder[ZonedDateTime] =
encoder(
Types.TIMESTAMP_WITH_TIMEZONE,
(index, value, row) => row.setTimestamp(index, Timestamp.from(value.toInstant))
)
implicit val instantEncoder: Encoder[Instant] =
encoder(Types.TIMESTAMP_WITH_TIMEZONE, (index, value, row) => row.setTimestamp(index, T... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.context.jdbc
import java.io.Closeable
import java.sql.{Connection, PreparedStatement}
import javax.sql.DataSource
import io.getquill.context.sql.idiom.SqlIdiom
import io.getquill.{NamingStrategy, ReturnAction}
import io.getquill.context.{ExecutionInfo, ProtoContext, ContextVerbTransla... | fim | zio/zio-quill | scala |
<|fim_suffix|>tion => Result[PreparedStatement]
override type PrepareActionResult = Connection => Result[PreparedStatement]
override type PrepareBatchActionResult = Connection => Result[List[PreparedStatement]]
def constructPrepareQuery(f: Connection => Result[PreparedStatement]): Connection => Result[Prepa... | fim | zio/zio-quill | scala |
<|fim_suffix|>BaseNullChecker {
override def apply(index: Int, row: ResultSet): Boolean =
// Note that JDBC-rows are 1-indexed
row.getObject(index + 1) == null
}
implicit val nullChecker: JdbcNullChecker = new JdbcNullChecker()
val dateTimeZone = TimeZone.getDefault
/**
* Parses instances o... | fim | zio/zio-quill | scala |
<|fim_suffix|>up])(info: ExecutionInfo, dc: Runner): Result[List[Long]] =
withConnectionWrapped { conn =>
groups.flatMap { case BatchGroup(sql, prepare, _) =>
val ps = conn.prepareStatement(sql)
logger.underlying.debug("Batch: {}", sql)
prepare.foreach { f =>
val (params, _) ... | fim | zio/zio-quill | scala |
<|fim_suffix|>: PrepareActionResult
def constructPrepareBatchAction(f: Connection => Result[List[PreparedStatement]]): PrepareBatchActionResult
private[getquill] val logger = ContextLogger(classOf[JdbcContext[_, _]])
def wrap[T](t: => T): Result[T]
def push[A, B](result: Result[A])(f: A => B): Result[B]
def... | fim | zio/zio-quill | scala |
<|fim_suffix|>]
): List[T] =
if (rs.next)
extractResult(rs, conn, extractor, extractor(rs, conn) :: acc)
else
acc.reverse
}
<|fim_prefix|>pa<|fim_middle|>ckage io.getquill.context.jdbc
import java.sql.{Connection, ResultSet}
import scala.annotation.tailrec
object ResultSetExtractor {
private[g... | fim | zio/zio-quill | scala |
<|fim_suffix|>TAMP
val idiom: D
}
trait SqliteJdbcTypes[+D <: SqliteDialect, +N <: NamingStrategy]
extends JdbcContextTypes[D, N]
with BasicTimeEncoders
with BasicTimeDecoders
with BooleanObjectEncoding
with UUIDObjectEncoding {
val idiom: D
}
trait SqliteExecuteOverride[+D <: SqliteDialect,... | fim | zio/zio-quill | scala |
<|fim_suffix|>es.OTHER, (index, value, row) => row.setObject(index, value, Types.OTHER))
implicit val uuidDecoder: Decoder[UUID] =
decoder((index, row, conn) => UUID.fromString(row.getObject(index).toString))
}
<|fim_prefix|>package io.getquill.context.jdbc
im<|fim_middle|>port java.sql.Types
import java.util.UU... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.context.jdbc
import java.sql.Types
import java.util.UUID
trait UUIDStringEncoding {
this: JdbcContextTypes[_, _] =>
implicit val uuidEncoder: Encoder[UUID] =
encoder(Types.VARCHAR, (index, value, row) => row.setString(index, v<|fim_suffix|>tString(index)))
}
<|fim_middle|>alu... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill
import io.getquill.context.Context
// Testing we are passing type params explicitly in<|fim_suffix|>PostgresDialect, _]
}
trait JDBCExtensions extends BaseExtensions {
override val context: PostgresJdbcContext[_]
}
<|fim_middle|>to JdbcContextBase, otherwise
// this file will fail... | fim | zio/zio-quill | scala |
<|fim_suffix|>s JdbcContextConfigSpec extends Spec {
"fail if cannot load dataSource" in {
intercept[IllegalStateException] {
JdbcContextConfig(ConfigFactory.empty()).dataSource
}
}
}
<|fim_prefix|>package io.getquill.context.jdbc
import com.typesafe.config.ConfigFactory
import io.getquill.JdbcC<|fim... | fim | zio/zio-quill | scala |
<|fim_suffix|> }
}
}
<|fim_prefix|>pa<|fim_middle|>ckage io.getquill.context.jdbc
import java.sql.{Connection, PreparedStatement, ResultSet}
import io.getquill.context.sql.ProductSpec
import io.getquill.util.Using.Manager
import org.scalactic.Equality
import scala.util.{Success, Failure}
trait PrepareJdbcSpecBas... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.context.jdbc.h2
import io.getquill.context.sql.encoding.ArrayEncodingBaseSpec
import java.sql.Timestamp
class ArrayJdbcEncodingSpec extends ArrayEncodingBaseSpec {
val ctx = testContext
import ctx._
val q = quote(query[ArraysTestEntity])
val corrected = e.copy(times... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.context.jdbc.h2
import io.getquill.context.sql.base.BatchValuesSpec
import io.getquill._
class BatchValuesJdbcSpec extends BatchValuesSpec {
val context = testContext
import testContext._
override def beforeEach(): Unit = {
testContext.run(sql"TRUNCATE TABLE Product; ALTE... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.context.jdbc.h2
import io.getquill.context.sql.base.CaseClassQuerySpec
import org.scalatest.matchers.should.Matchers._
class CaseClassQueryJdbcSpec extends CaseClassQuerySpec {
val context = testContext
import testContext._
override def b<|fim_suffix|>lt`
}
"Example 4 - ... | fim | zio/zio-quill | scala |
<|fim_suffix|>ies).foreach(p => departmentInsert(p)))
testContext.run(liftQuery(employeeEntries).foreach(p => employeeInsert(p)))
testContext.run(liftQuery(taskEntries).foreach(p => taskInsert(p)))
}
()
}
"Example 8 - nested naive" in {
testContext.run(`Example 8 expertise naive`(lift(`Exam... | fim | zio/zio-quill | scala |
<|fim_suffix|>Ex 9 DistinctOn With Sort`) mustEqual `Ex 9 DistinctOn With Sort Result`
}
"Ex 10 DistinctOn With Applicative Join" in { //
testContext.run(`Ex 10 DistinctOn With Applicative Join`) mustEqual `Ex 10 DistinctOn With Applicative Join Result`
}
"Ex 11 DistinctOn With Monadic Join" in {
testCo... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.context.jdbc.h2
import io.getquill.base.Spec
class JdbcContextSpec extends Spec {
import testContext._
val badEntity = quote {
querySchema[TestEntity]("TestEntity", _.s -> "a", _.i -> "i", _.l -> "l", _.o -> "o")
}
"provides transaction support" - {
"success" in {
... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.context.jdbc.h2
import io.getquill.context.sql.EncodingSpec
import java.time.ZoneId
class JdbcEncodingSpec extends EncodingSpec {
val context = testContext
import testContext._
"encodes and decodes <|fim_suffix|>ncodingTestEntity]))
}
"Encode/Decode Other Time Types" in... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.context.jdbc.h2
import io.getquill.context.sql.OptionQuerySpec
import org.scalatest.matchers.should.Matchers._
class OptionJdbcSpec extends OptionQuerySpec {
val context = testContext
import testContext._
override def beforeAll = {
testContext.transaction {
testCont... | fim | zio/zio-quill | scala |
<|fim_suffix|>eturningMany(_.generatedColumn) mod`._
val id = testContext.run(op)
testContext.run(get) mustEqual result(id.head)
}
// Not supported in H2
"Ex 2 update.returningMany(_.singleColumn) mod" ignore {
import `Ex 2 update.returningMany(_.singleColumn) mod`._
testContext.run(op) must cont... | fim | zio/zio-quill | scala |
<|fim_suffix|>(`Ex 10 page 2 query`) mustEqual `Ex 10 page 2 expected`
}
"Example 11 - filtered update" in {
testContext.run(`Ex 11 filtered update`)
testContext.run(`Ex 11 filtered update get`) must contain theSameElementsAs `Ex 11 filtered update expected`
}
"Example 12 - filtered update co-related"... | fim | zio/zio-quill | scala |
<|fim_suffix|>testContext.run(query[Product].delete)
}
def productExtractor = (rs: ResultSet, conn: Connection) => materializeQueryMeta[Product].extract(rs, conn)
val prepareQuery = prepare(query[Product])
"single" in {
val prepareInsert = prepare(query[Product].insertValue(lift(productEntries.head)))... | fim | zio/zio-quill | scala |
<|fim_suffix|>4").toLong)
}.head
queried.sku mustEqual 1004L
}
}
}
}
<|fim_prefix|>package io.getquill.context.jdbc.h2
import io.getquill.context.sql.ProductSpec
class ProductJdbcSpec extends ProductSpec {
val context = testContext
import testContext._
override def beforeAll = {
... | fim | zio/zio-quill | scala |
<|fim_suffix|>ders}
package object h2 {
object testContext extends H2JdbcContext(Literal, "testH2DB") with TestEntities with TestEncoders with TestDecoders
}
<|fim_prefix|>package io.getquill.context.jdbc
import io.getquill._
import i<|fim_middle|>o.getquill.context.sql.{TestDecoders, TestEnco<|endoftext|> | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.context.jdbc.mysql
import io.getquill.context.sql.base.BatchValuesSpec
import io.getquill._
class BatchValuesJdbcSpec extends BatchValuesSpec {
val context = testContext
import testContext._
override def beforeEach(): Unit = {
testContext.run(query[Product].delete)
te... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.context.jdbc.mysql
import io.getquill.context.sql.base.CaseClassQuerySpec
import org.scalatest.matchers.should.Matchers._
class CaseClassQueryJdbcSpec extends CaseClassQuerySpec {
val context = testContext
import testContext._
override def beforeAll = {
testContext.transa... | fim | zio/zio-quill | scala |
package io.getquill.context.jdbc.mysql
import io.getquill.context.sql.base.DepartmentsSpec
class DepartmentsJdbcSpec extends DepartmentsSpec {
val context = testContext
import testContext._
override def beforeAll = {
testContext.transaction {
testContext.run(query[Department].delete)
testConte... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.context.jdbc.mysql
import io.getquill.context.sql.DistinctSpec
import org.scalatest.matchers.should.Matchers._
class DistinctJdbcSpec extends DistinctSpec {
val context = testContext
import testContext._
override def beforeAll = {
testContext.transaction {
testConte... | fim | zio/zio-quill | scala |
<|fim_suffix|>.transaction {
testContext.run(qr1.insert(_.i -> 33))
throw new IllegalStateException
}
}
testContext.run(qr1).isEmpty mustEqual true
}
"nested" in {
testContext.run(qr1.delete)
testContext.transaction {
testContext.transaction {
... | fim | zio/zio-quill | scala |
<|fim_suffix|>ult()
val timeEntity = TimeEntity.make(zid)
context.run(query[TimeEntity].insertValue(lift(timeEntity)))
val actual = context.run(query[TimeEntity]).head
timeEntity mustEqual actual
}
}
<|fim_prefix|>package io.getquill.context.jdbc.mysql
import io.getquill.context.sql.EncodingSpec
impo... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.context.jdbc.mysql
import io.getquill.context.sql.base.OnConflictSpec
class OnConflictJdbcSpec extends OnConflictSpec {
val ctx = testContext
import ctx._
override protected def beforeAll(): Unit = {
ctx.run(qr1.delete)
()
}
"INSERT IGNORE" in {
import `onConf... | fim | zio/zio-quill | scala |
<|fim_suffix|>ld contain theSameElementsAs `Map+getOrElse LeftJoin Result`
}
"Example 6 - Map+Option+Flatten+getOrElse Join" in {
testContext.run(`Option+Some+None Normalize`) should contain theSameElementsAs `Option+Some+None Normalize Result`
}
"Example 7 - Filter with OrElse and Forall" in {
testCo... | fim | zio/zio-quill | scala |
<|fim_suffix|>un(get) mustEqual result(id.head)
}
// Not supported in MySQL
"Ex 2 update.returningMany(_.singleColumn) mod" ignore {
import `Ex 2 update.returningMany(_.singleColumn) mod`._
testContext.run(op) must contain theSameElementsAs expect
testContext.run(get) must contain theSameElementsAs r... | fim | zio/zio-quill | scala |
<|fim_suffix|>) mustEqual `Ex 5 expected result`
}
"Example 6 - predicate 0" in {
testContext.run(satisfies(eval(`Ex 6 predicate`))) mustEqual `Ex 6 expected result`
}
"Example 7 - predicate 1" in {
testContext.run(satisfies(eval(`Ex 7 predicate`))) mustEqual `Ex 7 expected result`
}
"Example 8 -... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.context.jdbc.mysql
import java.sql.{Connection, ResultSet}
import io.getquill.context.jdbc.PrepareJdbcSpecBase
import org.scalatest.BeforeAndAfter
class PrepareJdbcSpec extends Prepa<|fim_suffix|>context = testContext
import testContext._
before {
testContext.run(query[Produ... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.context.jdbc.mysql
import io.getquill.context.sql.ProductSpec
class ProductJdbcSpec extends ProductSpec {
val context = testContext
import testContext._
override def beforeAll = {
testContext.run(quote(query[Product].delete))
()
}
"Product" - {
"Insert multip... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.context.jdbc.mysql
import io.getquill.context.sql.base.QueryResultTypeSpec
import java.util.concurrent.ConcurrentLinkedQueue
import scala.jdk.CollectionConverters._
class QueryResultTypeJdbcSpec extends QueryResultTypeSpec {
override val context = testContext
import context._
... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.context.jdbc
import io.getquill._
import io.getquill.context.sql.{TestDecoders, TestEncoders}
package object mysql {
<|fim_suffix|>tDecoders
}
<|fim_middle|> object testContext
extends MysqlJdbcContext(Literal, "testMysqlDB")
with TestEntities
with TestEncoders
... | fim | zio/zio-quill | scala |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.