Skip to content

Commit

Permalink
Merge 910cd0b into bf6b8b6
Browse files Browse the repository at this point in the history
  • Loading branch information
@alexflav23
alexflav23 committed Mar 6, 2019
2 parents bf6b8b6 + 910cd0b commit 55289d4
Show file tree
Hide file tree
Showing 8 changed files with 228 additions and 110 deletions.
63 changes: 38 additions & 25 deletions phantom-dsl/src/main/scala/com/outworkers/phantom/builder/query/AlterQuery.scala
View file
Expand Up @@ -25,33 +25,48 @@ import com.outworkers.phantom.builder.{ConsistencyBound, QueryBuilder, Unspecifi
import com.outworkers.phantom.column.AbstractColumn
import com.outworkers.phantom.connectors.KeySpace

class AlterQuery[
case class AlterQuery[
Table <: CassandraTable[Table, _],
Record,
Status <: ConsistencyBound,
Chain <: WithBound
](table: Table, val qb: CQLQuery, val options: QueryOptions) extends RootQuery[Table, Record, Status] {
](
table: Table,
init: CQLQuery,
options: QueryOptions = QueryOptions.empty,
alterPart: AlterPart = AlterPart.empty,
addPart: AddPart = AddPart.empty,
dropPart: DropPart = DropPart.empty,
withPart: WithPart = WithPart.empty,
renamePart: RenamePart = RenamePart.empty
) extends RootQuery[Table, Record, Status] {

val qb: CQLQuery = (alterPart merge addPart merge dropPart merge renamePart merge withPart) build init

final def add(column: String, columnType: String, static: Boolean = false): AlterQuery[Table, Record, Status, Chain] = {
val query = if (static) {
QueryBuilder.Alter.addStatic(qb, column, columnType)
QueryBuilder.Alter.addStatic(column, columnType)
} else {
QueryBuilder.Alter.add(qb, column, columnType)
QueryBuilder.Alter.add(column, columnType)
}

new AlterQuery(table, query, options)
copy(addPart = addPart append query)
}

final def add(definition: CQLQuery): AlterQuery[Table, Record, Status, Chain] = {
new AlterQuery(table, QueryBuilder.Alter.add(qb, definition), options)
copy (addPart = addPart append definition)
}

final def alter[RR](columnSelect: Table => AbstractColumn[RR], newType: String): AlterQuery[Table, Record, Status, Chain] = {
new AlterQuery(table, QueryBuilder.Alter.alter(qb, columnSelect(table).name, newType), options)
copy(
alterPart = alterPart append QueryBuilder.Alter.alterType(columnSelect(table).name, newType)
)
}

final def rename[RR](select: Table => AbstractColumn[RR], newName: String) : AlterQuery[Table, Record, Status, Chain] = {
new AlterQuery(table, QueryBuilder.Alter.rename(qb, select(table).name, newName), options)
copy(
renamePart = renamePart append QueryBuilder.Alter.rename(select(table).name, newName)
)
}

/**
Expand Down Expand Up @@ -101,24 +116,22 @@ class AlterQuery[
* @return A new alter query with the underlying builder containing a DROP clause.
*/
final def drop(column: String): AlterQuery[Table, Record, Status, Chain] = {
new AlterQuery(table, QueryBuilder.Alter.drop(qb, column), options)
copy(dropPart = dropPart append CQLQuery(column))
}

@deprecated("Use option instead", "2.0.0")
final def `with`(clause: TablePropertyClause)(
implicit ev: Chain =:= WithUnchainned
): AlterQuery[Table, Record, Status, WithChainned] = {
new AlterQuery(table, QueryBuilder.Alter.option(qb, clause.qb), options)
}
): AlterQuery[Table, Record, Status, WithChainned] = option(clause)

final def option(clause: TablePropertyClause)(
implicit ev: Chain =:= WithUnchainned
): AlterQuery[Table, Record, Status, WithChainned] = {
new AlterQuery(table, QueryBuilder.Alter.option(qb, clause.qb), options)
copy(withPart = withPart append clause.qb)
}

final def and(clause: TablePropertyClause)(implicit ev: Chain =:= WithChainned): AlterQuery[Table, Record, Status, WithChainned] = {
new AlterQuery(table, QueryBuilder.Where.and(qb, clause.qb), options)
copy(withPart = withPart append clause.qb)
}

override def executableQuery: ExecutableCqlQuery = ExecutableCqlQuery(qb, options, Nil)
Expand Down Expand Up @@ -153,8 +166,7 @@ object AlterQuery {
): AlterQuery.Default[T, R] = {
new AlterQuery[T, R, Unspecified, WithUnchainned](
table,
QueryBuilder.Alter.alter(QueryBuilder.keyspace(keySpace.name, table.tableName).queryString),
QueryOptions.empty
QueryBuilder.Alter.alter(QueryBuilder.keyspace(keySpace.name, table.tableName).queryString)
)
}

Expand All @@ -166,14 +178,11 @@ object AlterQuery {
implicit keySpace: KeySpace
): AlterQuery.Default[T, R] = {

val qb = QueryBuilder.Alter.alter(
QueryBuilder.keyspace(keySpace.name, table.tableName).queryString
)

new AlterQuery(
table,
QueryBuilder.Alter.alter(qb, select(table).name, newType.dataType),
QueryOptions.empty
QueryBuilder.Alter.alter(QueryBuilder.keyspace(keySpace.name, table.tableName).queryString),
QueryOptions.empty,
AlterPart.empty append QueryBuilder.Alter.alterType(select(table).name, newType.dataType)
)
}

Expand All @@ -184,11 +193,15 @@ object AlterQuery {
implicit keySpace: KeySpace
): AlterQuery.Default[T, R] = {

val qb = QueryBuilder.Alter.alter(QueryBuilder.keyspace(keySpace.name, table.tableName).queryString)
val qb = QueryBuilder.Alter.alter(
QueryBuilder.keyspace(keySpace.name, table.tableName).queryString
)

new AlterQuery(
table,
QueryBuilder.Alter.rename(qb, select(table).name, newName),
QueryOptions.empty
qb,
QueryOptions.empty,
AlterPart.empty append QueryBuilder.Alter.rename(select(table).name, newName)
)
}
}
6 changes: 1 addition & 5 deletions phantom-dsl/src/main/scala/com/outworkers/phantom/builder/query/CreateQuery.scala
View file
Expand Up @@ -98,11 +98,7 @@ case class CreateQuery[

@implicitNotFound("You cannot use 2 `with` clauses on the same create query. Use `and` instead.")
final def `with`(clause: TablePropertyClause): CreateQuery[Table, Record, Status] = {
if (withClause.queries.isEmpty) {
copy(withClause = withClause append QueryBuilder.Create.`with`(clause.qb))
} else {
copy(withClause = withClause append QueryBuilder.Update.and(clause.qb))
}
copy(withClause = withClause append clause.qb)
}

/**
Expand Down
78 changes: 76 additions & 2 deletions phantom-dsl/src/main/scala/com/outworkers/phantom/builder/query/Parts.scala
View file
Expand Up @@ -150,7 +150,7 @@ object LightweightPart {
}

sealed class WithPart(override val queries: Seq[CQLQuery] = Seq.empty) extends CQLQueryPart[WithPart](queries) {
override def qb: CQLQuery = QueryBuilder.Update.clauses(queries)
override def qb: CQLQuery = QueryBuilder.Alter.withOptions(queries)

override def instance(l: Seq[CQLQuery]): WithPart = new WithPart(l)
}
Expand Down Expand Up @@ -184,4 +184,78 @@ object OptionPart {
def apply(qb: CQLQuery): OptionPart = new OptionPart(qb :: Nil)

def empty: OptionPart = new OptionPart()
}
}


sealed class AlterPart(
override val queries: Seq[CQLQuery] = Seq.empty
) extends CQLQueryPart[AlterPart](queries) {
override def qb: CQLQuery = {
if (queries.nonEmpty) {
QueryBuilder.Alter.alter(queries)
} else {
CQLQuery.empty
}
}

override def instance(list: Seq[CQLQuery]): AlterPart = new AlterPart(list)
}

object AlterPart {
def empty: AlterPart = new AlterPart(Nil)
}

sealed class AddPart(
override val queries: Seq[CQLQuery] = Seq.empty
) extends CQLQueryPart[AddPart](queries) {
override def qb: CQLQuery = {
if (queries.nonEmpty) {
QueryBuilder.Alter.addAll(queries)
} else {
CQLQuery.empty
}
}

override def instance(list: Seq[CQLQuery]): AddPart = new AddPart(list)
}

object AddPart {
def empty: AddPart = new AddPart(Nil)
}


sealed class RenamePart(
override val queries: Seq[CQLQuery] = Seq.empty
) extends CQLQueryPart[RenamePart](queries) {
override def qb: CQLQuery = {
if (queries.nonEmpty) {
QueryBuilder.Alter.rename(queries)
} else {
CQLQuery.empty
}
}

override def instance(list: Seq[CQLQuery]): RenamePart = new RenamePart(list)
}

object RenamePart {
def empty: RenamePart = new RenamePart(Nil)
}

sealed class DropPart(
override val queries: Seq[CQLQuery] = Seq.empty
) extends CQLQueryPart[DropPart](queries) {
override def qb: CQLQuery = {
if (queries.nonEmpty) {
QueryBuilder.Alter.dropAll(queries)
} else {
CQLQuery.empty
}
}

override def instance(list: Seq[CQLQuery]): DropPart = new DropPart(list)
}

object DropPart {
def empty: DropPart = new DropPart(Nil)
}

0 comments on commit 55289d4

Please sign in to comment.