text stringlengths 14 100k | source stringclasses 1
value | repo stringclasses 810
values | language stringclasses 13
values |
|---|---|---|---|
<|fim_prefix|>package io.getquill.norm
import io.getquill.base.Spec
import io.getquill.MirrorContexts.testContext.qr1
import io.getquill.MirrorContexts.testContext.qr2
import io.getquill.MirrorContexts.testContext.quote
import io.getquill.MirrorContexts.testContext.unquote
import io.getquill.util.TraceConfig
class Ad... | fim | zio/zio-quill | scala |
<|fim_suffix|>val n = quote {
qr1.join(qr2).on((y, b) => y.s == b.s).map(t => (t._1.s, t._2))
}
ApplyMap.unapply(q.ast) mustEqual Some(n.ast)
}
"right" in {
val q = quote {
qr1.join(qr2.map(y => y.s)).on((a, b) => a.s == b)
}
val n = quote {
... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.norm
import io.getquill.ast.{AscNullsFirst, Constant, Ident, Map, SortBy}
import io.getquill.MirrorContexts.testContext._
import io.getquill.Query
import io.getquill.base.Spec
class AttachToEntitySpec extends Spec {
val attachToEntity =
(AttachToEntity(SortBy(_, _, Constant.au... | fim | zio/zio-quill | scala |
<|fim_suffix|>o")
BetaReduction(ast, Ident("a", quat) -> CaseClass("CC", List(("foo", Ident("a'"))))) mustEqual
Ident("a'")
}
"applies reduction only once" in {
val ast: Ast = Ident("a")
BetaReduction(ast, Ident("a") -> Ident("b"), Ident("b") -> Ident("c")) mustEqual
Ident("b")
}
}
<|fim_... | fim | zio/zio-quill | scala |
package io.getquill.norm
import io.getquill.ReturnAction.{ReturnColumns, ReturnRecord}
import io.getquill._
import io.getquill.ast.Renameable.ByStrategy
import io.getquill.ast.Visibility.Visible
import io.getquill.ast._
import io.getquill.base.Spec
import io.getquill.context.{ExecutionType, Expand}
import io.getquill.... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.norm
import io.getquill.ast.{+&&+, _}
import io.getquill.MirrorContexts.testContext._
import io.getquill.ast.Implicits._
import io.getquill.norm.ConcatBehavior.{AnsiConcat, NonAnsiConcat}
import io.getquill.MoreAstOps._
import io.getquill.base.Spec
import io.getquill.util.TraceConfig
... | fim | zio/zio-quill | scala |
<|fim_suffix|>e (i, qrs) =>
i -> qrs.map(_.l).sum
}
}
val n = quote {
qr1.groupBy(p => p.i).map { p =>
p._1 -> p._2.map(x1 => x1.l).sum
}
}
new Normalize(TranspileConfig.Empty)(q.ast) mustEqual (n.ast)
}
}
<|fim_prefix|>package io.getquill.norm
import io.getquill.bas... | fim | zio/zio-quill | scala |
package io.getquill.norm
import io.getquill.base.Spec
class NormalizeCachingSpec extends Spec {
val normalize = new Normalize(TranspileConfig.Empty)
val cached = NormalizeCaching(normalize.apply)
val gen = new QueryGenerator(1)
"Cached normalization" - {
"consists with non-cached `Normalize`" i... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.norm
import io.getquill.base.Spec
import io.getquill.MirrorContexts.testContext.implicitOrd
import io.getquill.MirrorContexts.testContext.qr1
import io.getquill.MirrorContexts.testContext.qr2
import io.getquill.MirrorContexts.testContext.quote
import io.getquill.MirrorContexts.testCon... | fim | zio/zio-quill | scala |
package io.getquill.norm
import io.getquill.ReturnAction.{ReturnColumns, ReturnRecord}
import io.getquill.base.Spec
import io.getquill.context.mirror.Row
import io.getquill.{MirrorIdiomReturningSingle, MirrorIdiomReturningMulti}
import io.getquill.MirrorContexts.testContext._
import io.getquill.MirrorContexts.testCont... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.norm
import io.getquill.base.Spec
import io.getquill.MirrorContexts.testContext.implicitOrd
import io.getquill.MirrorContexts.testContext.qr1
import io.getquill.MirrorContexts.testContext.qr2
import io.getquill.MirrorContexts.testContext.quote
import io.getquill.MirrorContexts.testCon... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.norm
import io.getquill.base.Spec
import io.getquill.MirrorContexts.testContext.implicitOrd
import io.getquill.MirrorContexts.testContext.qr1
import io.getquill.MirrorContexts.testContext.qr2
import io.getquill.MirrorContexts.testContext.quote
import io.getquill.MirrorContexts.testCon... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.norm
import scala.util.Random
import io.getquill.ast._
import io.getquill.quat.Quat
class QueryGenerator(seed: Int) {
private val random = new Random(seed)
implicit final class IdentExt(id: Ident) {
def randomProperty: Ast =
id.quat match {
case Quat.Product(f... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.norm
import io.getquill.ast._
import io.getquill.ast.Implicits._
import io.getquill.base.Spec
import io.getquill.norm.EqualityBehavior.{AnsiEquality, NonAnsiEquality}
import io.getquill.MirrorContexts.testContext.{quote, unquote}
import io.getquill.MirrorContexts.testContext.extras._
... | fim | zio/zio-quill | scala |
<|fim_suffix|>xternal.Source.Parser, StabilizeLifts.Token(0), _, `quatA`),
StringOperator.`+`,
ScalarValueLift("b", External.Source.Parser, StabilizeLifts.Token(1), _, `quatB`)
) =>
}
val expectedTable = IMap(StabilizeLifts.Token(0) -> a, StabilizeLifts.Token(1) -> b)... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.norm
import io.getquill.base.Spec
import io.getquill.MirrorContexts.testContext.qr1
import io.getquill.MirrorContexts.testContext.qr2
import io.getquill.MirrorContexts.testContext.qr3
import io.getquill.MirrorContexts.testContext.quote
import io.getquill.MirrorContexts.testContext.unq... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.norm.capture
import io.getquill.MirrorContexts.testContext._
import io.getquill.Query
import io.getquill.base.Spec
import io.getquill.norm.{Normalize, TranspileConfig}
class AvoidAliasConflictComplexSpec extends Spec {
val normalize = new Normalize(TranspileConfig.Empty)
"prope... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.norm.capture
import io.getquill.MirrorContexts.testContext._
import io.getquill.Query
import io.getquill.base.Spec
import io.getquill.util.TraceConfig
class AvoidAliasConflictSpec extends Spec {
val AvoidAliasConflict = new AvoidAliasConflictApply(TraceConfig.Empty)
"renames al... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.n<|fim_suffix|>MirrorContexts.testContext.qr2
import io.getquill.MirrorContexts.testContext.qr3
import io.getquill.MirrorContexts.testContext.quote
import io.getquill.MirrorContexts.testContext.unquote
import io.getquill.util.TraceConfig
class AvoidCaptureSpec extends Spec {
"avoid... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.norm.capture
import io.getquill.base.Spec
import io.getquill.MirrorContexts.testContext.implicitOrd
import io.getquill.MirrorContexts.testContext.qr1
import io.getquill.MirrorContexts.testContext.qr2
import io.getquill.MirrorContexts.testContext.quote
import io.getquill.MirrorContexts... | fim | zio/zio-quill | scala |
<|fim_suffix|> Bool = Boolean
def func[T <: { def name: String; def isRussian: Bool }] = quote { (q: T) =>
q
}
func.ast.quat mustEqual Quat.Product("T", "name" -> Quat.Value, "isRussian" -> Quat.BooleanValue)
}
"case class" in {
case class MyPerson(name: String, isRussian: Boolea... | fim | zio/zio-quill | scala |
<|fim_suffix|>ntity]).dynamic.filterOpt(o)((v0, i) => v0.i == i),
query[TestEntity]
)
}
}
"map" in {
test(
quote(query[TestEntity]).dynamic.map(v0 => v0.i),
query[TestEntity].map(v0 => v0.i)
)
}
}
"actions" - {
def test[T](d: Quoted[Action[T]], s:... | fim | zio/zio-quill | scala |
<|fim_suffix|> val q = dynamicQuery[TestEntity]
testContext.run(q).string mustEqual ("""querySchema("TestEntity")""")
}
"filterOpt" in {
val o = Some(1)
val q = dynamicQuery[TestEntity].filterOpt(o)((t, i) => quote(t.i == i))
testContext.run(q).string mustEqual ("""querySchema("TestEn... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.quotation
import io.getquill.ast.IdentName
import io.getquill.base.Spec
import io.getquill.MirrorContexts.testContext.implicitOrd
import io.getquill.MirrorContexts.testContext.qr1
import io.getquill.MirrorContexts.testContext.qr2
import io.getquill.MirrorContexts.testContext.quote
imp... | fim | zio/zio-quill | scala |
<|fim_suffix|> IsDynamic(Property.Opinionated(Dynamic(1), "a", Fixed, Visible)) mustEqual true
}
}
"false" in {
IsDynamic(qr1.ast) mustEqual false
}
"false when using CaseClass" in {
IsDynamic(qrRegular.ast) mustEqual false
}
}
}
<|fim_prefix|>package io.getquill.quotation
impor... | fim | zio/zio-quill | scala |
<|fim_suffix|>ptionIsDefined(
ia
) +&&+ OptionIsDefined(ib) +&&+ (ia +==+ ib))
}
"succeeds when Option/T" in {
"""
val q = quote {
(a: Option[Int], b: Int) => a == b
}
""" mustNot compile
}
"s... | fim | zio/zio-quill | scala |
<|fim_suffix|> }
case class A(date: Option[Long] = None)
testContext.run(query[A].filter(a => a.date.valid)).string mustEqual
s"""querySchema("A").filter(a => sql"($${a.date} IS NULL OR $${a.date} > $${?})")"""
}
"rebinds function with args and" - {
"type param" in {
implicit class Inc(f... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.util
import io.getquill.base.Spec
import java<|fim_suffix|>
cache.getOrElseUpdate(1, _value, 1.second) mustEqual Some(value)
cache.getOrElseUpdate(1, _value, 1.second) mustEqual Some(value)
calls mustEqual 1
}
"caches misses" in {
val cache = new Cache[Int, Val... | fim | zio/zio-quill | scala |
<|fim_prefix|>pac<|fim_suffix|>st(1, 3)
val l2 = List(2)
Interleave(l1, l2) mustEqual List(1, 2, 3)
}
"second list with more elements" in {
val l1 = List(1)
val l2 = List(2, 3)
Interleave(l1, l2) mustEqual List(1, 2, 3)
}
}
<|fim_middle|>kage io.getquill.util
import io.getquill.base.Spec
cl... | fim | zio/zio-quill | scala |
<|fim_suffix|> Large(
| | 123,
| | "",
| | "Test",
| | "TestTest",
| | "TestTestTest",
| | "TestTestTestTest",
| | "TestTestTestTestTest",
| | "TestTestTestTestTestTest",
| | "TestTestTestTestT... | fim | zio/zio-quill | scala |
<|fim_suffix|>se()
contents must not be empty
contents must endWith(s"""${mockQuery};""")
}
}
<|fim_prefix|>package io.getquill.util
import io.getquill.base.Spec
import io.getquill.util.Messages.LogToFile
import scala.io.Source
class LogToFileSpec extends Spec {
// TODO temporarily ignore this test, wi... | fim | zio/zio-quill | scala |
<|fim_suffix|>.Spec
class ShowSpec extends Spec {
import Show._
"given a Show implicit, provides an implicit class with the show method" in {
implicit val show = Show[Int] {
_.toString
}
1.show mustEqual "1"
}
"provides a factory method that receives a function" in {
implicit val show ... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.doobie
import io.getquill._
import io.getquill.context.jdbc._
object DoobieContext {
class H2[+N <: NamingStrategy](val naming: N)
extends DoobieContextBase[H2Dialect, N]
with H2JdbcContextBase[H2Dialect, N] {
val idiom: H2Dialect = H2Dialect
}
<|fim_suffix|>Dia... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.doobie
import cats.data.Nested
import cats.syntax.all._
import cats.free.Free
import doobie.free.connection.ConnectionOp
import doobie._
import doobie.implicits._
import doobie.util.query.DefaultChunkSize
import fs2.Stream
import io.getquill.NamingStrategy
import io.getquill.context.s... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.doobie
import cats.effect._
import cats.syntax.all._
import doobie._
import doobie.implicits._
import io.getquill._
import org.scalatest.freespec.AnyFreeSpec
import org.scalatest.matchers.must.Matchers
import io.getquill.Literal
import io.getquill.context.sql.base.PeopleReturningSpec
... | fim | zio/zio-quill | scala |
package io.getquill.doobie
import cats.effect._
import cats.syntax.all._
import doobie._
import doobie.implicits._
import io.getquill._
import org.scalatest.freespec.AnyFreeSpec
import org.scalatest.matchers.must.Matchers
class PostgresDoobieContextSuite extends AnyFreeSpec with Matchers {
// Logging should appear... | fim | zio/zio-quill | scala |
<|fim_suffix|>s.must.Matchers
import io.getquill.doobie.DoobieContext
// https://github.com/tpolecat/doobie/issues/1067
class Issue1067 extends AnyFreeSpec with Matchers {
import cats.effect.unsafe.implicits.global
lazy val xa = Transactor.fromDriverManager[IO](
"org.postgresql.Driver",
s"jdbc:postgresql... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill
import fansi.Str
import io.getquill.ast.Renameable.{ByStrategy, Fixed}
import io.getquill.ast.Visibility.{Hidden, Visible}
import io.getquill.ast._
import io.getquill.quat.Quat
import io.getquill.util.Messages.QuatTrace
import pprint.{Renderer, Tree, Truncated}
object AstPrinter {
... | fim | zio/zio-quill | scala |
<|fim_suffix|>dded
<|fim_prefix|>package io.getqui<|fim_middle|>ll
trait Embe<|endoftext|> | fim | zio/zio-quill | scala |
<|fim_suffix|> OnConflict => c.token
case ast => super.astTokenizer.token(ast)
}
implicit def conflictTokenizer(implicit
astTokenizer: Tokenizer[Ast],
strategy: NamingStrategy,
idiomContext: IdiomContext
): Tokenizer[OnConflict] = {
import OnConflict._
def tokenizer(implicit... | fim | zio/zio-quill | scala |
<|fim_suffix|>gular => true
case _ => false
}
}
object Batch {
def unapply(qt: QueryType) =
qt match {
case BatchInsert(foreachAlias) => Some(foreachAlias)
case BatchUpdate(foreachAlias) => Some(foreachAlias)
case _ ... | fim | zio/zio-quill | scala |
<|fim_prefix|>package<|fim_suffix|>(f: I => O)
<|fim_middle|> io.getquill
case class MappedEncoding[I, O]<|endoftext|> | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill
import io.getquill.ast.Renameable.{ByStrategy, Fixed}
import io.getquill.ast.Visibility.Hidden
import io.getquill.ast.{Action => AstAction, Query => AstQuery, _}
import io.getquill.context.{CanReturnClause, ExecutionType}
import io.getquill.idiom.StatementInterpolator._
import io.getq... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill
import io.getquill.context.sql.idiom.{ConcatSupport, QuestionMarkBindVariables, SqlIdiom}
import io.getquill.context._
import io.getquill.norm.ProductAggregationToken
import io.getquill.sql.idiom.BooleanLiteralSupport
trait MirrorSqlDialect extends SqlIdiom with QuestionMarkBindVaria... | fim | zio/zio-quill | scala |
<|fim_suffix|>NonQuotedException()
def insert(f: (T => (Any, Any)), f2: (T => (Any, Any))*): Insert[T] = NonQuotedException()
def update(f: (T => (Any, Any)), f2: (T => (Any, Any))*): Update[T] = NonQuotedException()
def delete: Delete[T] = NonQuotedException()
}
sealed trait Action[E] extends QAC[E, Any]
se... | fim | zio/zio-quill | scala |
<|fim_suffix|>sAs: ActionTableAliasBehavior = ActionTableAliasBehavior.SkipAs
override def prepareForProbing(string: String) = {
val quoted = string.replace("'", "\\'")
s"PREPARE p${quoted.hashCode.abs.toString.token} FROM '$quoted'"
}
override def defaultAutoGeneratedToken(field: Token) = stmt"($field)... | fim | zio/zio-quill | scala |
<|fim_suffix|>pply[N1 <: NamingStrategy, N2 <: NamingStrategy, N3 <: NamingStrategy, N4 <: NamingStrategy](
n1: N1,
n2: N2,
n3: N3,
n4: N4
): CompositeNamingStrategy4[N1, N2, N3, N4] =
new CompositeNamingStrategy4(n1, n2, n3, n4)
private[getquill] def apply(strategies: List[NamingStrategy]) =
... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill
import io.getquill.ast._
import io.getquill.context.{CanInsertReturningWithSingleValue, CanInsertWithSingleValue, CanReturnMultiField}
import io.getquill.context.sql._
import io.getquill.context.sql.idiom.SqlIdiom.ActionTableAliasBehavior
import io.getquill.context.sql.idiom._
import ... | fim | zio/zio-quill | scala |
<|fim_suffix|>2.ord, o3.ord, o4.ord, o5.ord, o6.ord, o7.ord)))
def apply[T1, T2, T3, T4, T5, T6, T7, T8](
o1: Ord[T1],
o2: Ord[T2],
o3: Ord[T3],
o4: Ord[T4],
o5: Ord[T5],
o6: Ord[T6],
o7: Ord[T7],
o8: Ord[T8]
): Ord[(T1, T2, T3, T4, T5, T6, T7, T8)] =
Ord(TupleOrdering(List(o1.o... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill
import java.util.concurrent.atomic.AtomicInteger
import io.getquill.ast.{Action, Query, _}
import io.getquill.ast
import io.getquill.context.sql.idiom
import io.getquill.context.sql.idiom.SqlIdiom.{InsertUpdateStmt, copyIdiom}
import io.getquill.context.{CanInsertReturningWithMultiVal... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill
trait Que<|fim_suffix|>yProbing
<|fim_middle|>r<|endoftext|> | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill
sealed trait ReturnAction
object ReturnAction {
case object ReturnNothing extends ReturnAction
c<|fim_suffix|>ns(columns: List[String]) extends ReturnAction
case object ReturnRecord extends ReturnAction
}
<|fim_middle|>ase class Retur... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill
import io.getquill.ast._
import io.getquill.context.{CanInsertReturningWithMultiValues, CanInsertWithMultiValues, CanOutputClause}
import io.getquill.context.sql.idiom.SqlIdiom.ActionTableAliasBehavior
import io.getquill.context.sql.idiom._
import io.getquill.context.sql.norm.AddDropT... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill
import io.getquill.idiom.StatementInterpolator._
import io.getquill.context.sql.idiom._
import io.getquill.idiom.StatementInterpolator.Tokenizer
import io.getquill.idiom.{StringToken, Token}
import io.getquill.ast._
import io.getquill.context.{CanInsertReturningWithSingleValue, CanIns... | fim | zio/zio-quill | scala |
<|fim_suffix|> query.bestQuat)
}
final case class GroupByMap(query: Ast, byAlias: Ident, byBody: Ast, mapAlias: Ident, mapBody: Ast) extends Query {
override def quat: Quat = mapBody.quat
override def bestQuat: Quat = mapBody.bestQuat
}
final case class Aggregation(operator: AggregationOperator, ast: Ast) ext... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.ast
// Represents an Ident without a Quat
case class IdentName(name: String)
object Implicits {
implicit final class IdentOps(private val id: Ident) extends AnyVal {
def idName: IdentName = IdentName(id.name)
}
implicit final class AstOpsExt(private val body: Ast) extends ... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.ast
import scala.collection.immutable.Queue
import scala.reflect.ClassTag
/**
* The collection is treated as immutable internally but an ArrayBuffer is more
* efficient the<|fim_suffix|> case (_, transformer) =>
transformer.state
}
}
<|fim_middle|>n Collection.list at a... | fim | zio/zio-quill | scala |
<|fim_suffix|>ect RightJoin extends JoinType
case object FullJoin extends JoinType
<|fim_prefix|>package io.getquill.ast
sealed trait JoinType
case object InnerJoin extends Join<|fim_middle|>Type
case object LeftJoin extends JoinType
case obj<|endoftext|> | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.ast
sealed trait Operator
sealed trait UnaryOperator extends Operator
sealed trait PrefixUnaryOperator extends UnaryOperator
sealed trait PostfixUnaryOperator extends UnaryOperator
sealed trait BinaryOperator extends Operator
// In Scala 3 == and != are not stable iden... | fim | zio/zio-quill | scala |
<|fim_suffix|>}
<|fim_prefix|>package io.getquill.ast
trait StatefulTransformer[T] {
val state: T
def apply(e: Ast): (Ast, StatefulTransformer[T]) =
e match {
case e: Query => apply(e)
case e: Operation => apply(e)
case e: Action => apply(e)
case e... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.ast
object StatefulTransformerWithStack {
sealed trait History {
def ast: Option[Ast]
}
object History {
case object Root extends History { val ast = None }
case class Child(clause: Ast, prev: History) extends History {
def ast = Some(clause)
}
def app... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.ast
trait StatelessTransformer {
def applyIdent(id: Ident): Ident = id
def apply(e: Ast): Ast =
e match {
case e: Query => apply(e)
case e: Operation => apply(e)
case e: Action => apply(e)
case e: Value ... | fim | zio/zio-quill | scala |
<|fim_suffix|>.apply(a)
}
<|fim_prefix|>package io.getquill.ast
class Transform[T](p: PartialFunction[Ast, Ast]) extends StatelessTransformer {
override def apply(a: Ast) =
a match {
case a if (p.isDefinedAt(a)) => p(a)
case other => super.a<|fim_middle|>pply(other)
}
}
object... | fim | zio/zio-quill | scala |
<|fim_suffix|>ption[Int], sql: String, prepare: Prepare, extractor: Extractor[T])(
info: ExecutionInfo,
rn: Runner
): StreamResult[T]
}
<|fim_prefix|>package io.getquill.context
import io.getquill.{NamingStrategy, ReturnAction}
import io.getquill.ast.Ast
import io.getquill.quat.Quat
import scala.language.hi... | fim | zio/zio-quill | scala |
<|fim_suffix|>turningNotSupported extends ReturningNotSupported
object ReturningSingleFieldSupported extends ReturningSingleFieldSupported
object ReturningMultipleFieldSupported extends ReturningMultipleFieldSupported
object ReturningClauseSupported extends ReturningClauseSupported
object OutputClaus... | fim | zio/zio-quill | scala |
package io.getquill.context
import io.getquill.ReturnAction
import io.getquill.ast.ScalarLift
trait RowContext {
type PrepareRow
type ResultRow
protected val identityPrepare: Prepare = (p: PrepareRow, _: Session) => (Nil, p)
private val _identityExtractor: Extractor[Any] = (rr: ResultRow, _: Sess... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.context.cassandra
import io.getquill.ast.{IterableOperation, _}
import io.getquill.NamingStrategy
import io.getquill.context.{CannotReturn, ExecutionType}
import io.getquill.util.Messages.fail
import io.getquill.idiom.Idiom
import io.getquill.idiom.StatementInterpolator._
import io.ge... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.context.cassandra
import io.getquill.ast._
import io.getquill.norm.ConcatBehavior.AnsiConcat
import io.getquill.norm.EqualityBehavior.AnsiEquality
import io.getquill.norm.capture.AvoidAliasConflict
import io.getquill.norm.{FlattenOptionOperation, Normalize, RenameProperties, SimplifyN... | fim | zio/zio-quill | scala |
<|fim_suffix|>[Ast],
select: List[Ast],
distinct: Boolean
): CqlQuery =
q match {
case q: Entity =>
new CqlQuery(q, filter, orderBy, limit, select, distinct)
case (_: FlatMap) =>
fail(s"Cql doesn't support flatMap.")
case (_: Union) | (_: UnionAll) =>
fail(s"Cql d... | fim | zio/zio-quill | scala |
<|fim_suffix|> case List((q, i)) =>
Infix(parts, params.updated(i, Map(q, x, p)), pure, tr, quat)
case other =>
super.apply(q)
}
case other =>
super.apply(q)
}
}
<|fim_prefix|>package io.getquill.con<|fim_middle|>text.cassandra
import io.getquill.ast... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.context.mirror
case class MirrorSession(name: String)
object MirrorSess<|fim_suffix|>efaultMirrorSession")
}
<|fim_middle|>ion {
def default = MirrorSession("D<|endoftext|> | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.dsl
trait DateOps {
imp<|fim_suffix|>xtends Ordered[java.time.LocalDate] {
def compare(that: java.time.LocalDate): Int = value.compareTo(that)
}
implicit final class LocalTimeOps(val value: java.time.LocalTime) extends Ordered[java.time.LocalTime] {
def compare(that: ja... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.dsl
import io.getquill.quotation.NonQuotedException
import scala.annotation.compileTimeOnly
private[getquill] trait InfixDsl {
private[getquill] trait InfixValue {
def as[T]: T
def asCondition: Boolean
def pure: InfixValue
private[getquill] def generic: InfixValue... | fim | zio/zio-quill | scala |
<|fim_suffix|>
}
<|fim_prefix|>package io.getquill.dsl
import io.getquill.Ord
private[getquill] trait OrdDsl {
implicit def implicitOrd[T]: Or<|fim_middle|>d[T] = Ord.ascNullsFirst<|endoftext|> | fim | zio/zio-quill | scala |
<|fim_suffix|>onQuotedException()
}
<|fim_prefix|>package io.getquill.dsl
import io.getquill.quo<|fim_middle|>tation.NonQuotedException
import scala.annotation.compileTimeOnly
object UnlimitedTuple {
@compileTimeOnly(NonQuotedException.message)
def apply(values: Any*): Nothing = N<|endoftext|> | fim | zio/zio-quill | scala |
package io.getquill.idiom
import io.getquill.ast._
import io.getquill.context.{ExecutionType, IdiomReturningCapability}
import io.getquill.quat.Quat
import io.getquill.{IdiomContext, NamingStrategy}
trait Idiom extends IdiomReturningCapability {
private val _emptySetContainsToken: StringToken = StringToken("FAL... | fim | zio/zio-quill | scala |
<|fim_suffix|>ken, value: T): Token =
token match {
// Take the correct ((p:Person) => ScalarLift(p.name)) from the Map[uuid -> ((p:Person) => ScalarLift(p.<field-value>))] values
// using the uuid of the tag. Then plug in the row-value i.e. `Person` to get ScalarLift(p.<field-value>))
cas... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.idiom
import io.getquill.ast._
sealed trait Token extends Product with Serializable
sealed trait TagToken extends Token
final case class StringToken(string: String) extends Token {
override def toString: String = string
}
final case class ScalarTagToken(tag: ScalarTag) extends... | fim | zio/zio-quill | scala |
package io.getquill.idiom
import io.getquill.ast._
import io.getquill.util.Interleave
import io.getquill.util.Messages._
import scala.annotation.tailrec
import scala.collection.mutable.ListBuffer
//noinspection ConvertExpressionToSAM
object StatementInterpolator {
private[getquill] val emptyStatement: Statement ... | fim | zio/zio-quill | scala |
<|fim_suffix|>raceConfig
class AdHocReduction(traceConfig: TraceConfig) {
def unapply(q: Query) =
q match {
// ---------------------------
// *.filter
// a.filter(b => c).filter(d => e) =>
// a.filter(b => c && e[d := b])
case Filter(Filter(a, b, c), d, e) =>
val er = ... | fim | zio/zio-quill | scala |
<|fim_suffix|>bottleGin[gin := ginifySprit]).map(x: Tuple[(Bottle, Spirit)] => (x._1, x._2.map(spirit => ginifySpirit))) :Tuple[(Bottle, Gin)]
// a.map(b => c).groupBy(d => e) =>
// a.groupBy(b => e[d := c]).map(x => (x._1, x._2.map(b => c)))
// where: x._2.map(b => c).type == d.type
case Gr... | fim | zio/zio-quill | scala |
<|fim_suffix|>ap(f(a, b), b, c)
case Filter(IsEntity(a), b, c) => Filter(f(a, b), b, c)
case SortBy(IsEntity(a), b, c, d) => SortBy(f(a, b), b, c, d)
case DistinctOn(IsEntity(a), b, c) => DistinctOn(f(a, b), b, c)
case Map(_: GroupBy, _, _) | _: GroupByMap | _: Union | _: UnionAll | _: Joi... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.norm
import io.getquill.ast._
import io.getquill.util.Messages
import scala.collection.immutable.{Map => IMap}
/**
* How do we want beta reduction to treat Quats? Typically the right answer is
* when any variable x type X is reduced to t type T we check that T is a
* subtype of X... | fim | zio/zio-quill | scala |
<|fim_suffix|>ken
object ProductAggregationToken {
case object Star extends ProductAggregationToken
case object VariableDotStar extends ProductAggregationToken
}
<|fim_prefix|>package io.getqui<|fim_middle|>ll.norm
trait EqualityBehavior
object EqualityBehavior {
case object AnsiEquality extends Eq... | fim | zio/zio-quill | scala |
<|fim_suffix|> sealed trait HNil extends HList[Nothing] {
def ::[H](h: H): HList[H] = ConfigList.::[H, HNil](h, this)
}
case object HNil extends HNil
}
<|fim_prefix|>package io.getquill.norm
import io.getquill.norm.ConfigList._
import io.getquill.util.Messages.TraceType
import io.getquill.util.TraceConfig
fi... | fim | zio/zio-quill | scala |
<|fim_suffix|>m, naming, idiomContext)
ReturnColumns(initialExpand.map { case (ast, statement) => f(ast, statement) })
case ReturningSingleFieldSupported =>
val initialExpand = ExpandReturning(returning)(idiom, naming, idiomContext)
if (initialExpand.length == 1)
ReturnColumns(in... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.norm
import io.getquill.ast._
import io.getquill.ast.Implicits._
import io.getquill.norm.ConcatBehavior.NonAnsiConcat
import io.getquill.quat.QuatOps.HasBooleanQuat
import io.getquill.util.Messa<|fim_suffix|> OptionExists(OptionOrElse(a, b), alias, body) =>
val reducedA = Beta... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.norm
import io.getquill.ast.Ast
import io.getquill.ast.Query
import io.getquill.ast.StatelessTransformer
import io.getquill.norm.capture.{AvoidAliasConflictApply, DealiasApply}
import io.getquill.ast.Action
import io.getquill.util.Interpolator
import io.getquill.util.Messages.{TraceTy... | fim | zio/zio-quill | scala |
<|fim_suffix|>def apply(f: Ast => Ast): Ast => Ast = { ori =>
val (stabilized, state) = StabilizeLifts.stabilize(ori)
val normalized = cache.get(stabilized, ast => f(ast))
StabilizeLifts.revert(normalized, state)
}
}
<|fim_prefix|>package io.getquill.norm
import com.github.benmanes.caffeine.cac... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.norm
import io.getquill.ast._
class NormalizeNestedStructures(n<|fim_suffix|>=> Some(f(a, b))
}
}
<|fim_middle|>ormalize: Normalize) {
def unapply(q: Query): Option[Query] =
q match {
case e: Entity => None
case Map(a, b, c) => apply(a, c)(Map(_,... | fim | zio/zio-quill | scala |
<|fim_suffix|>me), normalize)
}
private def apply(e: Action, body: Ast, returningIdent: Ident): Action = e match {
case Insert(query, assignments) => Insert(query, filterReturnedColumn(assignments, body, returningIdent))
case Update(query, assignments) => Update(query, filterReturnedColum... | fim | zio/zio-quill | scala |
<|fim_suffix|> }
}
<|fim_prefix|>package io.getquill.norm
import io.getquill.ast._
object NormalizeStringConcat extends State<|fim_middle|>lessTransformer {
override def apply(ast: Ast): Ast = ast match {
case BinaryOperation(Constant("", _), StringOperator.`+`, b) => apply(b)
case _ ... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getq<|fim_suffix|> e).drop(n)
case Map(Drop(fm: FlatMap, n), ma, mb) =>
Some(Drop(Map(fm, ma, mb), n))
case other => None
}
}
<|fim_middle|>uill.norm
import io.getquill.ast._
import io.getquill.util.TraceConfig
class OrderTerms(traceConfig: TraceConfig) {
def unapp... | fim | zio/zio-quill | scala |
<|fim_suffix|>se other => super.apply(other)
}
}
object SeedRenames extends StatelessTransformer {
/**
* In the case that there are entities inside of an infix and the infix is
* cast to the same entity, propagate the renames from the entity inside of
* the infix to the external AST. For example sa... | fim | zio/zio-quill | scala |
<|fim_suffix|>> aliasR)
trace"Repropagate ${alias.quat.suppress(msg)} from $alias into:" andReturn
ReturningGenerated(actionR, aliasR, bodyR)
case oc @ OnConflict(oca: Action, target, act) =>
val actionR = apply(oca)
val targetR =
target match {
case OnConf... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.norm
import io.getquill.ast.{Aggregation, Ast, CaseClass, ConcatMap, Distinct, Filter, FlatMap, GroupBy, GroupByMap, Ident, Join, Map, Property, Query, StatefulTransformerWithStack, Union, UnionAll}
import io.getquill.ast.Ast.LeafQuat
import io.getquill.ast.StatefulTransformerWithStac... | fim | zio/zio-quill | scala |
<|fim_suffix|>
case OptionSome(value) => Some(value)
case value => Some(value)
}
}
}
<|fim_prefix|>package io.getquill.norm
import io.getquill.ast._
import io.getquill.ast.Implicits._
import io.getquill.norm.EqualityBehavior.AnsiEquality
/**
* Due to the introduction of null checks in... | fim | zio/zio-quill | scala |
<|fim_suffix|> case l: ScalarQueryLift =>
val value = state.replaceTable(l.value.asInstanceOf[Token])
l.copy(value = value)
case l: CaseClassValueLift =>
val value = state.replaceTable(l.value.asInstanceOf[Token])
l.copy(value = value)
case l: CaseClassQueryLift =>
... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.norm
import io.getquill.ast.{Filter, FlatMap, Query, Union, UnionAll}
import io.getquill.util.TraceConfig
/**
* This stage represents Normalization Stage1: Symbolic Reduction in Philip
* Wadler's Paper "A Practical Theory of Language Integrated Query", given in
* Figure 11.
* htt... | fim | zio/zio-quill | scala |
<|fim_prefix|>package io.getquill.norm.capture
import io.getquill.ast.{Entity, Filter, FlatJoin, FlatMap, GroupBy, Ident, Join, Map, Query, SortBy, StatefulTransformer, _}
import io.getquill.ast.Implicits._
import io.getquill.norm.{BetaReduction, Normalize}
import io.getquill.util.{Interpolator, TraceConfig}
import io... | 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.