text stringlengths 14 100k | source stringclasses 1
value | repo stringclasses 810
values | language stringclasses 13
values |
|---|---|---|---|
<|fim_suffix|>ivate[getquill] def withDatasource[T](schemaConfig: SchemaConfig, dbPrefix: ConfigPrefix)(
testCode: DataSource with Closeable => T
): T = {
val ds = dbPrefix.makeDatasource
val helper = new DbHelper(schemaConfig, dbPrefix, ds)
DbHelper.dropTables(ds)
helper.setup()
testCode(... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.codegen.util
import scala.util.{Failure, Try}
object TryOps {
implicit final class TryThrowExt[T](private val t: Try[T]) extends AnyVal {
def orThrow: T =
t match {
case scala.util.Success(<|fim_suffix|>
case Failure(e) => throw e
}
de... | fim | zio/zio-quill | scala |
package io.getquill
import io.getquill.context.{Context, ContextVerbTranslate, ExecutionInfo, RowContext}
import io.getquill.context.mirror.{MirrorDecoders, MirrorEncoders, MirrorSession, Row}
import scala.concurrent.Future
import io.getquill.monad.ScalaFutureIOMonad
import scala.concurrent.ExecutionContext
import i... | fim | zio/zio-quill | scala |
<|fim_suffix|>ef exec(): Unit = {
// PrintMac(run {
// for {
// p <- query[Address]
// a <- query[Person].leftJoin(a => a.id == p.owner)
// } yield (p, a)
// })
// }
// }
}
<|fim_prefix|>package io.getquill
import io.getquill.context.mirror.{MirrorSession,... | fim | zio/zio-quill | scala |
<|fim_suffix|>ime.AbstractFunction6
import scala.runtime.AbstractFunction7
import scala.runtime.AbstractFunction8
import scala.runtime.AbstractFunction9
import io.getquill.util.MacroContextExt._
import io.getquill.context.Context
trait ImplicitQuery {
this: Context[_, _] =>
implicit def toQuery[P <: Product](f: ... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill
impo<|fim_suffix|>ingMirror[O, List[O]](string, prepare(Row(), session)._2, extractor, returningBehavior, info)
def executeBatchAction(groups: List[BatchGroup])(info: ExecutionInfo, dc: Runner) =
BatchActionMirror(
groups.map { case BatchGroup(string, prepare, _) =>
... | fim | zio/zio-quill | scala |
<|fim_suffix|>QueryDslMacro
import io.getquill.quotation.NonQuotedException
sealed trait EntityQuery[T] extends EntityQueryModel[T] {
override def withFilter(f: T => Boolean): EntityQuery[T] = NonQuotedException()
override def filter(f: T => Boolean): EntityQuery[T] = NonQuotedException()
override def map[R... | fim | zio/zio-quill | scala |
<|fim_suffix|>ee
* <a
* href="https://youtrack.jetbrains.com/issue/SCL-20078/Scala-3.1.1-fails-to-compile-no-method-options#focus=Comments-27-6048464.0-0">Scala
* 3.1.1 fails to compile / no method options</a> for more info.
*/
trait Quoted[+T] {
def ast: Ast
override def toString: String = ast.toString
}... | fim | zio/zio-quill | scala |
<|fim_suffix|>dt
<|fim_prefix|>package io.getquill
trait<|fim_middle|> U<|endoftext|> | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.g<|fim_suffix|> AstOps {}
<|fim_middle|>etquill.ast
object<|endoftext|> | fim | zio/zio-quill | scala |
<|fim_suffix|>bleLiftList = q"$injectableLiftListTrees"
val (translatedAst, token, executionType, idiomContext, string, idiom) =
tryTranslateStatic(ast, Quat.Unknown, Some(alias.name)).fold(msg => c.fail(msg), x => x)
// Splice into the code to tokenize the ast (i.e. the Expand c... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.context
import com.typesafe.scalalogging.Logger
import scala.language.higherKinds
import scala.language.experimental.macros
import io.getquill.dsl.CoreDsl
import io.getquill.util.ContextLogger
import io.getquill.util.Messages.fail
import java.io.Closeable
import scala.util.Try
impor... | fim | zio/zio-quill | scala |
<|fim_suffix|>om.translate"
// The `idiomContext` variable uses scala's provided list-liftable and the optionalPhaseLiftable
q"""
val (idiom, naming) = ${idiomAndNamingDynamic}
val traceConfig = ${ConfigLiftables.traceConfigLiftable(transpileConfig.traceConfig)}
val idiomContext = _root_.io.ge... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.context
import io.getquill.{Action, BatchAction, Query, Quoted}
import io.getquill.dsl.CoreDsl
import scala.language.experimental.macros
import scala.language.higherKinds
trait ContextVerbPrepare extends CoreDsl {
type Result[T]
type Session
type PrepareQueryResult // Us... | fim | zio/zio-quill | scala |
<|fim_suffix|>PrepareRow]
type PrepareBatchActionResult = Session => Result[List[PrepareRow]]
}
<|fim_prefix|>package io.getquill.contex<|fim_middle|>t
trait ContextVerbPrepareLambda extends ContextVerbPrepare {
type PrepareQueryResult = Session => Result[PrepareRow]
type PrepareActionResult = Session... | fim | zio/zio-quill | scala |
package io.getquill.context
import io.getquill.{NamingStrategy, Query, Quoted}
import scala.language.higherKinds
import scala.language.experimental.macros
trait ContextVerbStream[+Idiom <: io.getquill.idiom.Idiom, +Naming <: NamingStrategy] {
this: Context[Idiom, Naming] =>
type StreamResult[T]
def stream[T]... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.context
import io.getquill.ast.ScalarLift
import io.getquill.{Action, BatchAction, NamingStrategy, Query, Quoted}
import io.getquill.idiom.Idiom
import scala.annotation.tailrec
import scala.language.experimental.macros
import scala.language.higherKinds
trait ContextVerbTranslate ext... | fim | zio/zio-quill | scala |
<|fim_suffix|> val newRow = encoder(idx, lift.value, row, session)
(idx + 1, lift.value :: values, newRow)
}
(values, prepare)
}
}
<|fim_prefix|>package io.getquill.context
import io.getquill.ast._
import io.getquill.idiom._
import io.getquill.{IdiomContext, NamingStrategy}
object CanDoBatc... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.context
import scala.concurrent.duration.DurationInt
import scala.reflect.api.Types
import scala.reflect.macros.whitebox<|fim_suffix|> cache = new Cache[Types#Type, Context[Idiom, NamingStrategy]]
def apply(statement: String, c: MacroContext): Unit = {
import c.universe.{Try =>... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.context
import io.getquill.ast._
import io.getquill.quat.Quat
import scala.reflect.macros.whitebox.{Context => MacroContext}
import io.getquill.util.{EnableReflectiveCalls, Messages, OptionalTypecheck}
class QueryMacro(val c: MacroContext) extends ContextMacro {
import c.universe.... | fim | zio/zio-quill | scala |
<|fim_suffix|>quill.util.MacroContextExt._
object VerifyFreeVariables {
def apply(c: MacroContext)(ast: Ast): Ast =
FreeVariables.verify(ast) match {
case Right(ast) => ast
case Left(msg) => c.fail(msg)
}
}
<|fim_prefix|>package io.getquill.context
import scala.reflect.macros.whitebox.{Context... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.context.mirror
import java.time.LocalDate
import java.util.{Date, UUID}
import scala.reflect.ClassTag
import io.getquill.context.Context
trait MirrorDecoders {
this: Context[_, _] =>
override type PrepareRow = Row
override type ResultRow = Row
override type Decoder[T] = Mi... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.context.mirror
import java.time.LocalDate
import java.util.{Date, UUID}
import io.getquill.context.Context
trait MirrorEncoders {
this: Context[_, _] =>
override type PrepareRow = Row
override type ResultRow = Row
override type Encoder[T] = MirrorEncoder[T]
override type... | fim | zio/zio-quill | scala |
package io.getquill.context.mirror
import scala.reflect.ClassTag
/**
* Defines a artificial 'Row' used for the mirror context. Mostly used for
* testing. (Note that this must not be in quill-engine or it will conflict with
* the io.getquill.context.mirror.Row class in ProtoQuill.)
*/
case class Row private (data:... | fim | zio/zio-quill | scala |
<|fim_suffix|>
with DynamicQueryDsl
<|fim_prefix|>package io.getquill.dsl
private[getquill] trait CoreDsl
extend<|fim_middle|>s InfixDsl
with OrdDsl
with QueryDsl
with QuotationDsl
with EncodingDsl
with MetaDsl<|endoftext|> | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.dsl
import io.getquill.ast.Renameable.Fixed
import io.getquill.ast._
import io.getquill.quat._
import io.getquill.util.Messages._
import io.getquill.{ActionReturning, Delete, EntityQuery, Insert, Ord, Query, Quoted, Update, Action => DslAction}
import scala.annotation.tailrec
import ... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.dsl
import io.getquill.quotation.NonQuotedException
import scala.annotation.compileTimeOnly
import scala.language.experimental.macros
import scala.language.higherKinds
import io.getquill.Query
trait LowPriorityImplicits {
this: EncodingDsl =>
implicit def anyValEncoder[T <: Any... | fim | zio/zio-quill | scala |
<|fim_suffix|>ructor(tpe).map(_.paramLists.flatten).collect { case param :: Nil =>
f(param)
}
}
private def primaryConstructor(t: Type) =
t.members.collect {
case m: MethodSymbol if m.isPrimaryConstructor => m.typeSignature.asSeenFrom(t, t.typeSymbol)
}.headOption
}
<|fim_prefix|>... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.dsl
import scala.language.experimental.macros
import io.getquill.{EntityQuery, Insert, Query, Quoted, Update}
trait M<|fim_suffix|>ta[T](exclude: (T => Any)*): UpdateMeta[T] = macro MetaDslMacro.updateMeta[T]
def insertMeta[T](exclude: (T => Any)*): InsertMeta[T] = macro MetaDslMac... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.dsl
import io.getquill.util.MacroContextExt._
import <|fim_suffix|>"!$isNull($index, row)")
case Nested(_, tpe, params, optional) =>
if (optional) {
val dualGroups: Seq[List[(FieldExpansion, Boolean)]] =
params.map(_.map(v => expandRecurse(... | fim | zio/zio-quill | scala |
<|fim_suffix|>b: Option[B]): Boolean = b.exists(bv => bv != a)
def =!=[B: Numeric](b: B): Boolean = a != b
}
}
trait LowPriorityExtras {
implicit final class OptionOps[T](a: Option[T]) {
def ===(b: Option[T]): Boolean = a.exists(av => b.exists(bv => av == bv))
def ===(b: T): Boole... | fim | zio/zio-quill | scala |
<|fim_suffix|>{TypeName(s"${prefix}Meta")}[$t]", c.TYPEmode)
c.inferImplicitValue(expanderTpe.tpe, silent = true) match {
case EmptyTree => c.fail(s"Can't find an implicit `${prefix}Meta` for type `${t.tpe}`")
case tree => tree
}
}
}
<|fim_prefix|>package io.getquill.dsl
import io.getquill.u... | fim | zio/zio-quill | scala |
package io.getquill.dsl
import io.getquill.Quoted
import io.getquill.quat.Quat
import scala.language.experimental.macros
import scala.language.implicitConversions
import scala.reflect.macros.whitebox.Context
import io.getquill.quotation.NonQuotedException
import io.getquill.quotation.Quotation
import scala.annotatio... | fim | zio/zio-quill | scala |
<|fim_suffix|>(term: Option[TermName], tpe: Type, decoder: Tree, optional: Boolean) extends Value {
def nestedAndOptional: Boolean = false
}
private def is[T](tpe: Type)(implicit t: TypeTag[T]) =
tpe <:< t.tpe
private[getquill] def value(encoding: String, tpe: Type, exclude: Tree*): Value = {
def n... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.idiom
import scala.reflect.macros.whitebox.Context
import scala.util.Try
import io.getquill.NamingStrategy
import io.getquill.util.CollectTry
import io.getquill.util.LoadObject
import io.getquill.CompositeNamingStrategy
object LoadNaming {
def static(c: Context)(tpe: c.Type): Try... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io<|fim_suffix|>tquill.util.ContextLogger
object ContextLog {
private val logger = ContextLogger(this.getClass)
def apply(str: String): Unit =
logger.underlying.error(str)
}
<|fim_middle|>.getquill.log
import io.ge<|endoftext|> | fim | zio/zio-quill | scala |
<|fim_suffix|>=> IO[S, E2]): IO[S, E with E2] =
TransformWith(this, f)
def transform[S](f: Try[T] => Try[S]): IO[S, E] =
transformWith { r =>
IO.fromTry(f(r))
}
def lowerFromTry[U](implicit ev: T => Try[U]) =
transform(_.flatMap(ev))
def liftToTry: IO[Try[T], E] =
tr... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.monad
import scala.reflect.macros.blackbox.{Context => MacroContext}
import scala.concurrent.ExecutionContext
class IOMonadMacro(val c: MacroContext) {
import c.universe._
def runIO(quoted: Tree): Tree =
q"${c.prefix}.Run(() => ${c.prefix}.run($quoted))"
def runIOEC(quote... | fim | zio/zio-quill | scala |
package io.getquill.monad
import io.getquill.context.Context
import language.experimental.macros
import language.higherKinds
import scala.collection.compat._
import scala.util.Failure
import scala.util.Success
import scala.concurrent.Future
import scala.concurrent.ExecutionContext
import io.getquill.{Action, ActionRe... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.monad
import scala.language.higherKinds
import scala.collection.compat._
import language.experimental.macros
import io.getquill.context.Context
import scala.annotation.tailrec
import scala.util.Try
import io.getquill.{Action, ActionReturning, BatchAction, Query, Quoted}
trait SyncIO... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.quat
import io.getquill.quotation.LiftUnlift
import scala.reflect.macros.whitebox.{Context => MacroContext}
class QuatMacro(val c: MacroContext) extends QuatMaking {
import c.universe._
def makeQuat[T: c.WeakTypeTag]: c.Tree = {
val quat <|fim_suffix|> = liftUnlift.quatLift... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.quat
import io.getquill.quotation.{MacroUtilBase, MacroUtilUniverse}
import java.lang.reflect.Method
import io.getquill.{Embedded, Udt}
import io.getquill.util.{Messages, OptionalTypecheck}
import scala.annotation.tailrec
import scala.collection.mutable.HashMap
import scala.reflect.... | fim | zio/zio-quill | scala |
<|fim_suffix|>ro QuatMacro.makeQuat[T]
}
<|fim_prefix|>package io.getquill
import scala.language.experimental.macros
/**
*<|fim_middle|> Convenience API that allows construction of a Quat using `Quat.from[T]`
*/
package object quat {
def quatOf[T]: Quat = mac<|endoftext|> | fim | zio/zio-quill | scala |
<|fim_suffix|>_.scala.language.reflectiveCalls
$quoted.bindings.$m
}
"""
}
.toMap
}
}
<|fim_prefix|>package io.getquill.quotation
import scala.reflect.macros.whitebox.Context
object Bindings {
def apply(c: Context)(quoted: c.Tree, tpe: c.Type): Map[c.Symbol, c... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.quotation
import io.getquill.ast.Ast<|fim_suffix|>.ast.CollectAst
import io.getquill.ast.Dynamic
object IsDynamic {
def apply(a: Ast) =
CollectAst(a) { case d: Dynamic => d }.nonEmpty
}
<|fim_middle|>
import io.getquill<|endoftext|> | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.quotation
import io.getquill.Quoted
import scala.reflect.macros.whitebox.Context
import io.getquill.ast._
import io.getquill.quat.Quat
trait Liftables extends QuatLiftable {
val mctx: Context
import mctx.universe.{Ident => _, Constant => _, Function => _, If => _, Block => _, _}
... | fim | zio/zio-quill | scala |
<|fim_suffix|>(s"### Going to base type for ${tpe} for expected base type ${of}")
paramOf(base, of, maxDepth - 1)
}
}
<|fim_prefix|>package io.getquill.quotation
import io.getquill.{IdiomContext, Quoted}
import scala.reflect.api.Universe
import scala.reflect.macros.whitebox.Context
trait MacroUtilBase e... | fim | zio/zio-quill | scala |
<|fim_suffix|>alParser: Parser[Val] = Parser[Val] { case q"$mods val $name: $typ = ${patMatchParser(value)}" =>
Val(ident(name, inferQuat(q"$typ".tpe)), value)
}
val patMatchParser: Parser[Ast] = Parser[Ast] { case q"$expr match { case ($fields) => $body }" =>
patMatchParser(expr, fields, body)
}
priv... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.quotation
import io.getquill.quat.Quat
import scala.reflect.macros.whitebox.Context
trait QuatLiftable {
val mctx: Context
val serializeQuats: Boolean
import mctx.universe.{Block => _, Constant => _, Function => _, Ident => _, If => _, _}
// Liftables are invariant so want... | fim | zio/zio-quill | scala |
<|fim_suffix|>leanExpression" => Quat.BooleanExpression
}
implicit def listUnliftable[T](implicit u: Unliftable[T]): Unliftable[List[T]] = Unliftable[List[T]] {
case q"$pack.Nil" => Nil
case q"$pack.List.apply[..$t](..$values)" => values... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.quotation
import scala.annotation.StaticAnnotation
import scala.reflect.ClassTag
import scala.reflect.macros.whitebox.Context
import io.getquill.ast._
import io.getquill.util.MacroContextExt._
import io.getquill.norm.BetaReduction
import io.getquill.util.Messages.TraceType
import io.g... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.quotation
import scala.reflect.macros.whitebox.Context
import io.getquill.ast.Ast
import io.getquill.ast.Function<|fim_suffix|>peSignature.asInstanceOf[infer.c.universe.Type])
) // TODO Verify Quat
def paramIdents(method: MethodSymbol) =
method.paramLists.flatten.map(... | fim | zio/zio-quill | scala |
<|fim_suffix|>nTableFlatMap =>
super.apply(p) match {
case (p2 @ OptionTableFlatMap(_: CaseClassValueLift, _, _), _) => apply(lift(unparse(p2)))
case other => other
}
case p: OptionTableMap =>
super.apply(... | fim | zio/zio-quill | scala |
<|fim_suffix|> => q"io.getquill.util.Messages.TraceType.RenameProperties"
case TraceType.ApplyMap => q"io.getquill.util.Messages.TraceType.ApplyMap"
case TraceType.Warning => q"io.getquill.util.Messages.TraceType.Warning"
case TraceType.ExprModel => q"io.... | fim | zio/zio-quill | scala |
<|fim_suffix|>$pack.AggregationOperator.`avg`" => AggregationOperator.`avg`
case q"$pack.AggregationOperator.`sum`" => AggregationOperator.`sum`
case q"$pack.AggregationOperator.`size`" => AggregationOperator.`size`
}
implicit val queryUnliftable: Unliftable[Query] = Unliftable[Query] {
case q"$pack.... | fim | zio/zio-quill | scala |
<|fim_suffix|>ze }].size" ::
Nil
}
}
<|fim_prefix|>package io.getquill.util
import scala.reflect.macros.<|fim_middle|>blackbox.Context
object EnableReflectiveCalls {
def apply(c: Context) = {
import c.universe._
q"import _root_.scala.language.reflectiveCalls" ::
q"Nil.asInstanceOf[{ def si<|e... | fim | zio/zio-quill | scala |
<|fim_suffix|>eam = new ByteArrayOutputStream()
val writer = new java.io.BufferedWriter(new java.io.OutputStreamWriter(stream))
t.printStackTrace(new java.io.PrintWriter(writer))
writer.flush()
stream.toString
}
}
}
<|fim_prefix|>package io.getquill.util
import java.io.ByteArrayOutputStre... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.util
import scala.reflect.macros.whitebox.Con<|fim_suffix|>ld.get(cls).asInstanceOf[T]
}
}
<|fim_middle|>text
import scala.util.Try
object LoadObject {
def apply[T](c: Context)(tpe: c.Type): Try[T] =
Try {
val cls = Class.forName(tpe.typeSymbol.fullName + "$")
... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.util
import io.getquill.idiom.Idiom
import io.getquill.util.IndentUtil._
import io.getquill.util.Messages.{debugEnabled, errorPrefix, prettyPrint}
import io.getquill.quat.VerifyNoBranches
import scala.reflect.macros.blackbox.{Context => MacroContext}
object MacroContextExt {
priv... | fim | zio/zio-quill | scala |
<|fim_suffix|>v == None
}
<|fim_prefix|>package io.getquill.util
object NullCheck {
def product(v: AnyRef) = v == nul<|fim_middle|>l || <|endoftext|> | fim | zio/zio-quill | scala |
package io.getquill.util
import scala.reflect.macros.blackbox.{Context => MacroContext}
object OptionalTypecheck {
def apply(c: MacroContext)(tree: c.Tree): Option[c.Tree] =
c.typecheck(tree, silent = true) match {
case c.universe.EmptyTree => None
case tree => Some(tree)
}
}
<|... | fim | zio/zio-quill | scala |
<|fim_suffix|>g
case None =>
val newBuilder = makeBuilder
map(key) = newBuilder
newBuilder
}
builder += i
}
map.mapValues(_.result).toMap
}
}
}
<|fim_prefix|>package io.getquill.util
import scala.collection.immutable.ListSet
import scala.c... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getqui<|fim_suffix|>apply(value: Any): Unit = macro PrintMacMacro.apply
}
<|fim_middle|>ll.util
import scala.language.experimental.macros
object PrintMac {
def <|endoftext|> | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.util
import scala.reflect.macros.whitebox.{Context => MacroContext}
class P<|fim_suffix|>intMacMacro(val c: MacroContext) {
import c.universe._
def apply(value: Tree): Tree = {
println(
"================= Printing Tree =================\n" +
show(value)
)
... | fim | zio/zio-quill | scala |
package io.getquill.util
import io.getquill.util.Messages.LogToFile
import zio._
import zio.logging._
import zio.logging.extensions.executeWithLogger
import java.nio.file.Paths
import java.time.ZonedDateTime
import java.time.format.DateTimeFormatter
class QueryLogger(logToFile: LogToFile) {
def apply(queryString:... | fim | zio/zio-quill | scala |
<|fim_suffix|>.internal.FileWriter(
destination,
charset,
autoFlushBatchSize,
bufferedIOSize,
rollingPolicy
)
)
}(writer => ZIO.succ... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill
import io.getquill.base.Spec
import io.getquill.MirrorContexts._
class AsyncMirrorContextSpec extends Spec {
val ctx = testAsyncContext
import ctx._
"executeQuery" in {
eval(ctx.run(qr1))
}
"executeQuerySingle" in {
eval(ctx.run(qr1.map(_.i).max))
}
"executeA... | fim | zio/zio-quill | scala |
<|fim_suffix|>r(t => t.s == "s")"""
}
"fails if querying a non-case-class companion" in {
"""
val q = quote {
Test.filter(_.a == "s")
}
""" mustNot compile
}
"only attempts to convert case class derived AbstractFunctionN to Query" - {
"preserves inferred type of secondary join Funct... | fim | zio/zio-quill | scala |
<|fim_suffix|>teral) with TestEntities
"probe" in {
ctx.probe("Ok").toOption mustBe defined
ctx.probe("Fail").toOption mustBe empty
}
"close" in {
ctx.close()
}
}
<|fim_prefix|>package io.getquill
import io.getquill.base.Spec
class MirrorContextSpec extends Spec {
val ctx = new<|fim_middle|> M... | fim | zio/zio-quill | scala |
<|fim_suffix|>res: Try[T] = Failure(new IllegalStateException())
f.onComplete(res = _)
res.get
}
}
}
<|fim_prefix|>package io.getquill
import scala.concurrent.{ExecutionContext, Future}
import scala.util.{Failure, Try}
object MirrorContexts {
object testContext extends TestMirrorContextTemplate(... | fim | zio/zio-quill | scala |
<|fim_suffix|>
trait MirrorIdiomReturningMulti extends MirrorIdiomBase with CanReturnMultiField
object MirrorIdiomReturningMulti extends MirrorIdiomReturningMulti
// Mirror idiom not supporting any returns
trait MirrorIdiomReturningUnsupported extends MirrorIdiomBase with CannotReturn
object MirrorIdiomReturningUnsu... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill
import io.getquill.ast._
object MoreAstOps {
implicit final class AstOpsExt2(private val body: Ast) extends AnyVal {
def +++(other: Co<|fim_suffix|>eration(body, NumericOperator.`>`, other)
}
}
<|fim_middle|>nstant): BinaryOperation =
if (other.v.isInstanceOf[String])
... | fim | zio/zio-quill | scala |
package io.getquill
import io.getquill.base.Spec
class NamingStrategySpec extends Spec {
"uses the default impl" in {
val s = new NamingStrategy with LowerCase
s.table("VALUE") mustEqual "value"
s.column("VALUE") mustEqual "value"
}
"can override table strategy" in {
val s = new NamingStrateg... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill
import io.getquill.MirrorContexts.testContext._
import io.getquill.ast.{Query => _, _}
import io.getquill.base.Spec
import io.getquill.quat._
class OpsSpec extends Spec {
"quotes asts" - {
"explicitly" in {
val q = quote {
query[TestEntity]
}
q.ast mu... | fim | zio/zio-quill | scala |
package io.getquill
import io.getquill.base.Spec
import io.getquill.context.mirror.{MirrorSession, Row}
class OptionalProductEncodingSpec extends Spec {
val ctx = new MirrorContext(PostgresDialect, Literal)
import ctx._
"optional product with optional embedded row" in {
case class Name(first: String, last... | fim | zio/zio-quill | scala |
package io.getquill
import io.getquill.base.Spec
class QueryProbingSpec extends Spec {
"fails if the context can't be resolved at compile time" in {
object c extends MirrorContext(MirrorIdiom, Literal) with TestEntities with QueryProbing
import c._
"c.run(qr1)" mustNot compile
}
"doesn't warn if q... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.get<|fim_suffix|>", "s" -> QV, "i" -> QV), "l" -> QV, "o" -> QV)
val TestEntity2Quat = Quat.Product("TestEntity2", "s" -> QV, "i" -> QV, "l" -> QV, "o" -> QV)
val TestEntity3Quat = Quat.Product("TestEntity3", "s" -> QV, "i" -> QV, "l" -> QV, "o" -> QV)
val TestEntity4Quat = Quat.... | fim | zio/zio-quill | scala |
<|fim_suffix|>}
<|fim_prefix|>package io.getquill
import io.getquill.ast.Renameable.Fixed
import io.getquill.ast.{Entity, PropertyAlias}
import io.getquill.base.Spec
import io.getquill.context.mirror.Row
import io.getquill.quat._
import io.getquill.MirrorContexts.testContext
class UnlimitedOptionalEmbedd<|fim_middle|... | fim | zio/zio-quill | scala |
package io.getquill
trait UpperCaseNonDefault extends NamingStrategy {
override def column(s: String): String = s.toUpperCase
override def table(s: String): String = s.toUpperCase
override def default(s: String) = s
}
object UpperCaseNonDefault extends UpperCaseNonDefault
trait UpperCaseEscapeColumn ext... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill
import io.getquill.ast.{Ast, Ident}
import io.getquill.quat.Quat
/**
* For unit tests that do not care about the `Quat` of an ident, use this class
* to construct an Ident with Quat.Value and ignore the Quat when
* deconstructing.
*/
object VIdent {
def unapply(id: Ast): Option... | fim | zio/zio-quill | scala |
<|fim_suffix|> val r = VIdent("r")
val prop = Property(r, "value")
"must match returning" in {
Returning(insert, r, prop) must matchPattern { case ReturningAction(`insert`, `r`, `prop`) =>
}
}
"must match returning generated" in {
ReturningGenerated(insert, r, prop) must matchP... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.ast
import io.getquill.ast.Renameable.Fixed
import io.getquill.ast.Visibility.Visible
import io.getquill.base.Spec
class StatefulTransformerSpec extends Spec {
case class Subject(state: List[Ast], replace: (Ast, Ast)*) extends StatefulTransformer[List[Ast]] {
override def appl... | fim | zio/zio-quill | scala |
<|fim_suffix|>l, QEP) -> Entity("b", Nil, QEP))(ast) mustEqual
Val(Ident("a"), Entity("b", Nil, QEP))
}
}
}
<|fim_prefix|>package io.getquill.ast
import io.getquill.ast.Renameable.Fixed
import io.getquill.ast.Visibility.Visible
import io.getquill.base.Spec
class StatelessTransformerSpec extends Spec {
... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.base
import io.getquill.context.Context
import java.util.Date
import scala.annotation.nowarn
trait EncodingSpec extends Spec {
val c: Context[_, _]
import c._
case class EncodingTestEntity(
v1: String,
v2: BigDecimal,
v3: Boolean,
v4: Byte,
v5: Short,
... | fim | zio/zio-quill | scala |
package io.getquill.base
import io.getquill.ast.{Ident, StatelessTransformer}
import io.getquill.context.ExecutionType
import io.getquill.norm.capture.TemporaryIdent
import io.getquill.quat.Quat
import io.getquill.{BatchActionMirrorGeneric, BatchActionReturningMirrorGeneric}
import org.scalatest.BeforeAndAfterAll
impo... | fim | zio/zio-quill | scala |
<|fim_suffix|>v.s -> lift('s1'), v => v.i -> lift(2), v => v.l -> lift(3), v => v.o -> lift(Some(4)), v => v.b -> lift(true))""",
"""querySchema("TestEntity").insert(v => v.s -> lift('s5'), v => v.i -> lift(6), v => v.l -> lift(7), v => v.o -> lift(Some(8)), v => v.b -> lift(false))"""
)
}
"tuple ... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.context
import io.getquill.base.Spec
import io.getquill.context.mirror.{MirrorSession, Row}
import io.getquill.MirrorContexts.testContext._
import io.getquill.MirrorContexts.testContext
class BindMacroSpec extends Spec {
val session = MirrorSession("test")
"binds non-batched ac... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.context
import io.getquill.base.Spec
import io.getquill.context.mirror.{MirrorSession, Row}
import io.getquill.MirrorContexts.testContext
import io.getquill.MirrorContexts.testContext._
case class ValueClass(value: Int) extends AnyVal
case class GenericValueClass[T](value: T) extend... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.context
import io.getquill.MirrorContexts.testContext
import io.getquill.MirrorContexts.testContext._
import mirror.Row
import io.getquill.MirrorContext
import io.getquill.NamingStrategy
import io.get<|fim_suffix|>al r = testContext.run(q)
r.string mustEqual """querySchema("Te... | fim | zio/zio-quill | scala |
<|fim_suffix|>ntext.run(q)(new Thread)" mustNot compile
}
"uses a custom implicit encoder" in {
implicit val doubleEncoder = testContext.encoder[Double]
val d = 1d
val q = quote {
qr1.map(t => lift(d))
}
testContext.run(q).prepareRow mustEqual Row(1d)
}
"fails fo... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.context
import io.getquill.base.Spec
import io.getquill.context.mirror.Row
import io.getquill.MirrorContexts.testContext
import io.getquill.MirrorContexts.testContext._
class QueryMacroSpec extends Spec {
"runs query with nested optional case class" in {
val q = quote {
... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.context.encoding
import io.getquill.context.Context
import io.getquill.Insert
import io.getquill.base.Spec
import org.scalatest.BeforeAndAfterEach
trait OptionalNestedSpec extends Spec with BeforeAndAfterEach {
val context: Context[_, _]
import context._
object Setup {
ca... | fim | zio/zio-quill | scala |
<|fim_suffix|> { (a: Int, b: Int) =>
a <= b
}
stmt"${(q.ast: Ast).token}" mustEqual
stmt"""(a, b) => a <= b"""
}
"/" in {
val q = quote { (a: Int, b: Int) =>
a / b
}
stmt"${(q.ast: Ast).token}" mustEqual
stmt"""(a, b) => a / b"""
}
"%" in {
... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io<|fim_suffix|>llegalStateException] {
r[String](0)
}
()
}
}
<|fim_middle|>.getquill.context.mirror
import io.getquill.base.Spec
class RowSpec extends Spec {
"adds value" in {
val r = Row(1, 2)
r.add(3) mustEqual Row(1, 2, 3)
}
"gets value by index" in {
val ... | fim | zio/zio-quill | scala |
<|fim_suffix|> }
import tag._
sealed trait CustomTag
type CustomInt = Int @@ CustomTag
"encoder" in {
implicit val encodeCustomValue = MappedEncoding[CustomInt, Int](_ + 1)
val enc = implicitly[Encoder[CustomInt]]
enc(0, tag[CustomTag][Int](1), Row(), MirrorS... | fim | zio/zio-quill | scala |
<|fim_suffix|> {
val meta = updateMeta[Entity](_.c.map(_.i))
meta.expand.toString mustEqual
"(q, value) => q.update(v => v.a -> value.a, v => v.b.i -> value.b.i, v => v.b.l -> value.b.l, v => v.c.map((v) => v.l) -> value.c.map((v) => v.l))"
}
}
}
"insert meta" - {
"materiali... | fim | zio/zio-quill | scala |
<|fim_suffix|>tEqual u.ast
}
}
"expands updates" - {
"default meta" in {
val q = quote { (t: TestEntity) =>
qr1.updateValue(t)
}
val u = quote { (t: TestEntity) =>
qr1.update(
v => v.s -> t.s,
v => v.i -> t.i,
v => v.l -> t.l,
v => v... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.monad
import java.util.concurrent.atomic.AtomicInteger
import scala.util.Success
import scala.util.Try
import scala.util.Failure
import io.getquill.monad.Effect.Write
import io.getquill.TestEntities
import io.getquill.base.Spec
import io.getquill.context.Context
trait IOMonadSpec ex... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.monad
import scala.concurrent.Future
import scala.concurrent.ExecutionContext
class ScalaFutureIOMonadSpec extends IOMonadSpec {
override val ctx = io.getquill.MirrorContexts.testAsyncContext
import ctx._
override def eval[T](io: IO[T, _]) =
ctx.eval(ctx.performIO(io))
... | fim | zio/zio-quill | scala |
<|fim_suffix|> val t = TestEntity("1", 2, 3L, Some(4), true)
val q = quote(qr1.insertValue(lift(t)).returning(_.i))
eval(ctx.runIO(q)).string mustEqual ctx.run(q).string
}
"RunBatchActionResult" in {
val l = List(TestEntity("1", 2, 3L, Some(4), true))
val q = quote(liftQuery(l).foreac... | 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.