@@ -1,60 +1,73 @@

 Package: RGMQL

 Type: Package

 Title: GenoMetric Query Language for R/Bioconductor

-Version: 0.99.27

+Version: 0.99.28

 Author: Simone Pallotta, Marco Masseroli

 Maintainer: Simone Pallotta <simonepallotta@hotmail.com>

-Description: This RGMQL package brings the GenoMetric Query Language (GMQL) functionalities into the R environment.

-  GMQL is a high-level, declarative language to query and compare multiple and heterogeneous genomic 

-  datasets for biomedical knowledge discovery. It allows expressing easily queries 

-  and processing over genomic regions and their metadata, in a way similar to 

-  what can be done with the Structured Query Language (SQL) over a relational database, 

-  to extract genomic regions of interest and compute their properties. 

-  GMQL adopts algorithms designed for big data and their efficient implementation 

-  using cloud-computing technologies, including Apache Hadoop framework and Spark engine; 

-  these make GMQL able to run on modern high performance computing infrastructures, 

-  CPU clusters and network infrastructures, in order to achieve scalability 

-  and performance on big data.

-  With GMQL very complex genomic operations can be written as simple queries, 

-  with implicit iteration over thousands of heterogeneous samples, and computed

-  efficiently in few minutes over servers or clouds.

-  This RGMQL package is built over a scalable data management engine written in 

-  Scala programming language, released as Scala API; it provides a set of functions 

-  to create, manipulate and extract genomic data from different data sources 

-  both from local and remote datasets. These RGMQL functions allow performing 

-  complex queries and processing without knowing the GMQL syntax, 

-  but leveraging on R idiomatic paradigm and logic.

-  RGMQL provides two different approaches in writing GMQL queries and processing scripts:

-  a) REST calls

-  b) standard R APIs

-  The REST approach let users to log into a remote infrastructure where a GMQL system 

-  is installed, and manage remote big genomic datasets hosted in cluster-based repository.

-  User can download an entire remote dataset into local folder, upload local datasets

-  into the remote repository or compiling and running a textual query or processing script

-  just invoking the right RGMQL functions.

-  Multiple REST invocations can be invoked and run concurrently on remote infrastructure 

-  allowing user to monitor the progress status of every call.

-  Many other REST functionalities are available in order to allow a complete interaction with remote infrastructure.

-  The R APIs approach lets user work with local or remote datasets using batch-like style 

-  where single invocations must be invoked sequentially; with this approach all 

-  GMQL queries and processing can be written as a sequence of RGMQL functions.

-  Unlike other similar packages, every RGMQL function simply builds a query,

-  with no intermediate result shown (except for a few functions that execute queries 

-  and for some utility functions for interoperability with other packages)

-  The RGMQL package also provides a rich set of ancillary classes that allow

-  sophisticated input/output management and sorting, such as ASC, DESC, BAG, MIN, 

-  MAX, SUM, AVG, MEDIAN, STD, Q1, Q2, Q3, and several others;

-  these classes are used only to build predicates and complex conditions taken as 

-  input by RGMQL functions; Note that many RGMQL functions are not directly executed 

-  in R environment, but are deferred until real execution is issued.

+Description: This RGMQL package brings the GenoMetric Query Language (GMQL)

+    functionalities into the R environment. GMQL is a high-level, declarative

+    language to query and compare multiple and heterogeneous genomic datasets

+    for biomedical knowledge discovery. It allows expressing easily queries and

+    processing over genomic regions and their metadata, in a way similar to what

+    can be done with the Structured Query Language (SQL) over a relational database,

+    to extract genomic regions of interest and compute their properties. GMQL

+    adopts algorithms designed for big data and their efficient implementation

+    using cloud-computing technologies, including Apache Hadoop framework and

+    Spark engine; these make GMQL able to run on modern high performance computing

+    infrastructures, CPU clusters and network infrastructures, in order to achieve

+    scalability and performance on big data. With GMQL very complex genomic

+    operations can be written as simple queries, with implicit iteration over

+    thousands of heterogeneous samples, and computed efficiently in few minutes over

+    servers or clouds. This RGMQL package is built over a scalable data management

+    engine written in Scala programming language, released as Scala API; it provides

+    a set of functions to create, manipulate and extract genomic data from different

+    data sources both from local and remote datasets. These RGMQL functions allow

+    performing complex queries and processing without knowing the GMQL syntax,

+    but leveraging on R idiomatic paradigm and logic. RGMQL provides two different

+    approaches in writing GMQL queries and processing scripts: a) REST calls b)

+    standard R APIs The REST approach let users to log into a remote infrastructure

+    where a GMQL system is installed, and manage remote big genomic datasets hosted

+    in cluster-based repository. User can download an entire remote dataset into

+    local folder, upload local datasets into the remote repository or compiling

+    and running a textual query or processing script just invoking the right RGMQL

+    functions. Multiple REST invocations can be invoked and run concurrently on

+    remote infrastructure allowing user to monitor the progress status of every

+    call. Many other REST functionalities are available in order to allow a complete

+    interaction with remote infrastructure. The R APIs approach lets user work with

+    local or remote datasets using batch-like style where single invocations must

+    be invoked sequentially; with this approach all GMQL queries and processing

+    can be written as a sequence of RGMQL functions. Unlike other similar packages,

+    every RGMQL function simply builds a query, with no intermediate result shown

+    (except for a few functions that execute queries and for some utility functions

+    for interoperability with other packages) The RGMQL package also provides a rich

+    set of ancillary classes that allow sophisticated input/output management and

+    sorting, such as ASC, DESC, BAG, MIN, MAX, SUM, AVG, MEDIAN, STD, Q1, Q2, Q3,

+    and several others; these classes are used only to build predicates and complex

+    conditions taken as input by RGMQL functions; Note that many RGMQL functions are

+    not directly executed in R environment, but are deferred until real execution is

+    issued.

 License: Artistic-2.0

 URL: http://www.bioinformatics.deib.polimi.it/genomic_computing/GMQL/

 Encoding: UTF-8

 LazyData: true

 RoxygenNote: 6.0.1

-Imports: httr, rJava,GenomicRanges, rtracklayer, data.table, utils, plyr, xml2, 

-    methods, S4Vectors, dplyr, stats

-Depends: R(<= 3.4.2)

+Imports:

+    httr,

+    rJava,GenomicRanges,

+    rtracklayer,

+    data.table,

+    utils,

+    plyr,

+    xml2,

+    methods,

+    S4Vectors,

+    dplyr,

+    stats

+Depends:

+    R(>= 3.4.2)

 VignetteBuilder: knitr

-Suggests: BiocStyle, knitr, rmarkdown

+Suggests:

+    BiocStyle,

+    knitr,

+    rmarkdown

 biocViews: Software,Infrastructure,DataImport,Network

@@ -32,15 +32,11 @@ export(compile_query)

 export(compile_query_fromfile)

 export(cover)

 export(delete_dataset)

-export(difference)

 export(download_as_GRangesList)

 export(download_dataset)

 export(execute)

 export(export_gmql)

-export(extend)

 export(filter_and_extract)

-export(flat)

-export(histogram)

 export(import_gmql)

 export(init_gmql)

 export(join)

@@ -48,9 +44,6 @@ export(login_gmql)

 export(logout_gmql)

 export(map)

 export(materialize)

-export(merge)

-export(order)

-export(project)

 export(read)

 export(read_dataset)

 export(remote_processing)

@@ -60,7 +53,6 @@ export(sample_metadata)

 export(sample_region)

 export(save_query)

 export(save_query_fromfile)

-export(select)

 export(show_datasets_list)

 export(show_job_log)

 export(show_jobs_list)

@@ -68,15 +60,24 @@ export(show_queries_list)

 export(show_samples_list)

 export(show_schema)

 export(stop_job)

-export(summit)

 export(take)

 export(trace_job)

-export(union)

 export(upload_dataset)

+exportMethods(aggregate)

+exportMethods(cover)

+exportMethods(filter)

+exportMethods(join)

+exportMethods(materialize)

+exportMethods(mutate)

+exportMethods(setdiff)

+exportMethods(sort)

+exportMethods(subset)

+exportMethods(union)

 import(GenomicRanges)

 import(httr)

 import(xml2)

 importClassesFrom(GenomicRanges,GRangesList)

+importClassesFrom(S4Vectors,DataTable)

 importFrom(GenomicRanges,makeGRangesFromDataFrame)

 importFrom(S4Vectors,metadata)

 importFrom(data.table,fread)

@@ -1,3 +1,10 @@

+#' @name cover

+#' @rdname cover-methods

+#' @aliases cover

+#' @export

+setGeneric("cover", function(data, minAcc, maxAcc, ...) 

+                                standardGeneric("cover"))

+

 #' GMQL Operation: COVER

 #'

 #' It takes as input a dataset containing one or more samples and returns 

@@ -27,7 +34,7 @@

 #' @importFrom rJava .jnull

 #' @importFrom rJava .jarray

 #' 

-#' @param input_data returned object from any GMQL function

+#' @param data GMQLDataset class object

 #' @param minAcc minimum number of overlapping regions to be considered 

 #' during execution

 #' Is a integer number, declared also as string.

@@ -84,11 +91,25 @@

 #' }

 #' "mixed style" is not allowed

 #'

-#' @return DataSet class object. It contains the value to use as input 

+#' @param variation string identifying the cover GMQL function variation.

+#' The admissible string are:

+#' \itemize{

+#' \item{flat: returns the contiguous region that starts from the first end 

+#' and stops at the last end of the regions which would contribute 

+#' to each region of the \emph{cover}.}

+#' \item{summit: returns regions that start from a position

+#' where the number of intersecting regions is not increasing afterwards and

+#' stops at a position where either the number of intersecting regions 

+#' decreases, or it violates the max accumulation index.}

+#' \item{histogram: returns the non-overlapping regions contributing to 

+#' the cover, each with its accumulation index value, which is assigned to 

+#' the AccIndex region attribute.}

+#' \item{cover: default value.}

+#' }

+#'

+#' @return GMQLDataset class object. It contains the value to use as input 

 #' for the subsequent GMQL function

 #' 

-#' @seealso \code{\link{summit}} \code{\link{flat}} \code{\link{histogram}}

-#'

 #' @examples

 #' 

 #' ## This statement produces an output dataset with a single output sample. 

@@ -99,7 +120,7 @@

 #' init_gmql()

 #' test_path <- system.file("example","DATASET",package = "RGMQL")

 #' exp = read_dataset(test_path)

-#' res = cover(input_data = exp, 2, ANY())

+#' res = cover(exp, 2, ANY())

 #'

 #' \dontrun{

 #' ## This GMQL statement computes the result grouping the input exp samples 

@@ -114,213 +135,21 @@

 #' exp = read_dataset(test_path)

 #' res = cover(exp, 2, 3, c("cell"), list(min_pValue = MIN("pvalue")))

 #' }

+#' @name cover

+#' @rdname cover-methods

+#' @aliases cover, GMQLDataset-methods

 #' @export

-#'

-cover <- function(input_data, minAcc, maxAcc, groupBy = NULL, 

-                    aggregates = NULL)

-{

-    minAcc <- .trasform_cover(deparse(substitute(minAcc)))

-    maxAcc <- .trasform_cover(deparse(substitute(maxAcc)))

-    

-    min <- .check_cover_param(minAcc,TRUE)

-    max <- .check_cover_param(maxAcc,FALSE)

-    

-    .doVariant("COVER",minAcc,maxAcc,groupBy,aggregates,input_data)

-}

+setMethod("cover", "GMQLDataset",

+            function(data, minAcc, maxAcc, groupBy = NULL, aggregates = NULL, 

+                        variation = "cover")

+            {

+                gmql_cover(data@value, minAcc, maxAcc, groupBy, aggregates, 

+                            variation)

+            })

-#' GMQL Operation: HISTOGRAM

-#'

-#' returns the non-overlapping regions contributing to the cover,

-#' each with its accumulation index value, which is assigned to 

-#' the AccIndex region attribute.

-#'

-#' @importFrom methods is

-#' @importFrom rJava J

-#' @importFrom rJava .jnull

-#' @importFrom rJava .jarray

-#' 

-#' @param input_data returned object from any GMQL function

-#' @param minAcc minimum number of overlapping regions to be considered 

-#' during execution

-#' Is a integer number, declared also as string.

-#' minAcc accept also:

-#' \itemize{

-#' \item{PARAMETER class object: \code{\link{ALL}} that represents the number 

-#' of samples in the input dataset}

-#' \item{and expression built using PARAMETER object: (ALL() + N) / K or

-#' ALL() / K }

-#' }

-#' @param maxAcc maximum number of overlapping regions to be considered 

-#' during execution

-#' Is a integer number, declared also as string.

-#' maxAcc accept also:

-#' \itemize{

-#' \item{PARAMETER class object: \code{\link{ALL}} that represents the number 

-#' of samples in the input dataset}

-#' \item{PARAMETER calss object: \code{\link{ANY}}} that acts as a wildcard, 

-#' considering any amount of overlapping.

-#' \item{and expression built using PARAMETER object: (ALL() + N) / K or

-#' ALL() / K }

-#' }

-#' @param groupBy list of CONDITION objects where every object contains 

-#' the name of metadata to be used in semijoin, or simple string concatenation 

-#' of name of metadata, e.g. c("cell_type", "attribute_tag", "size") 

-#' without declaring condition.

-#' The CONDITION's available are:

-#' \itemize{

-#' \item{\code{\link{FULL}}: Fullname evaluation, two attributes match 

-#' if they both end with value and, if they have a further prefixes,

-#' the two prefix sequence are identical}

-#' \item{\code{\link{EXACT}}: Exact evaluation, only attributes exactly 

-#' as value will match; no further prefixes are allowed. }

-#' }

-#' Every condition accepts only one string value. (e.g. FULL("cell_type") )

-#' In case of single concatenation with no CONDITION or list with some value 

-#' without conditon, the metadata are considered having default 

-#' evaluation: the two attributes match if both end with value.

-#' 

-#' @param aggregates list of element in the form \emph{key} = \emph{aggregate}.

-#' The \emph{aggregate} is an object of class AGGREGATES

-#' The aggregate functions available are: \code{\link{SUM}}, 

-#' \code{\link{COUNT}}, \code{\link{MIN}}, \code{\link{MAX}}, 

-#' \code{\link{AVG}}, \code{\link{MEDIAN}}, \code{\link{STD}}, 

-#' \code{\link{BAG}}, \code{\link{BAGD}}, \code{\link{Q1}}, 

-#' \code{\link{Q2}}, \code{\link{Q3}}.

-#' Every aggregate accepts a string value, execet for COUNT, which does not 

-#' have any value.

-#' Argument of 'aggregate function' must exist in schema, i.e. among region 

-#' attributes. Two style are allowed:

-#' \itemize{

-#' \item list of key-value pairs: e.g. sum = SUM("pvalue")

-#' \item list of values: e.g. SUM("pvalue")

-#' }

-#' "mixed style" is not allowed

-#'

-#' @return DataSet class object. It contains the value to use as input 

-#' for the subsequent GMQL function

-#' 

-#' @seealso \code{\link{flat}} \code{\link{cover}} \code{\link{summit}}

-#'

-#' @examples

-#'

-#' ## This GMQL statement computes the result grouping the input \emph{exp} 

-#' ## samples by the values of their \emph{cell} metadata attribute, 

-#' ## thus one output \emph{res} sample is generated for each cell type. 

-#' ## Output regions are produced by dividing results from COVER in contiguous 

-#' ## subregions according to the varying accumulation values 

-#' ## (from 2 to 4 in this case): one region for each accumulation value;

-#'

-#' init_gmql()

-#' test_path <- system.file("example", "DATASET", package = "RGMQL")

-#' exp = read_dataset(test_path)

-#' res = histogram(exp, 2, 4, groupBy = c("cell"))

-#' 

-#' @export

-#'

-histogram <- function(input_data, minAcc, maxAcc, groupBy = NULL, 

-                        aggregates = NULL)

-{

-    minAcc <- .trasform_cover(deparse(substitute(minAcc)))

-    maxAcc <- .trasform_cover(deparse(substitute(maxAcc)))

-    

-    min <- .check_cover_param(minAcc,TRUE)

-    max <- .check_cover_param(maxAcc,FALSE)

-    

-    .doVariant("HISTOGRAM",minAcc,maxAcc,groupBy,aggregates,input_data)

-}

-#' GMQL Operation: SUMMIT

-#'

-#' returns regions that start from a position

-#' where the number of intersecting regions is not increasing afterwards and

-#' stops at a position where either the number of intersecting regions 

-#' decreases, or it violates the max accumulation index.

-#'

-#' @importFrom methods is

-#' @importFrom rJava J

-#' @importFrom rJava .jnull

-#' @importFrom rJava .jarray

-#' 

-#' @param input_data returned object from any GMQL function

-#' @param minAcc minimum number of overlapping regions to be considered 

-#' during execution

-#' Is a integer number, declared also as string.

-#' minAcc accept also:

-#' \itemize{

-#' \item{PARAMETER class object: \code{\link{ALL}} that represents the number 

-#' of samples in the input dataset}

-#' \item{and expression built using PARAMETER object: (ALL() + N) / K or

-#' ALL() / K }

-#' }

-#' @param maxAcc maximum number of overlapping regions to be considered 

-#' during execution

-#' Is a integer number, declared also as string.

-#' maxAcc accept also:

-#' \itemize{

-#' \item{PARAMETER class object: \code{\link{ALL}} that represents the number 

-#' of samples in the input dataset}

-#' \item{PARAMETER calss object: \code{\link{ANY}}} that acts as a wildcard, 

-#' considering any amount of overlapping.

-#' \item{and expression built using PARAMETER object: (ALL() + N) / K or

-#' ALL() / K }

-#' }

-#' @param groupBy list of CONDITION objects where every object contains 

-#' the name of metadata to be used in semijoin, or simple string concatenation 

-#' of name of metadata, e.g. c("cell_type", "attribute_tag", "size") 

-#' without declaring condition.

-#' The CONDITION's available are:

-#' \itemize{

-#' \item{\code{\link{FULL}}: Fullname evaluation, two attributes match 

-#' if they both end with value and, if they have a further prefixes,

-#' the two prefix sequence are identical}

-#' \item{\code{\link{EXACT}}: Exact evaluation, only attributes exactly 

-#' as value will match; no further prefixes are allowed. }

-#' }

-#' Every condition accepts only one string value. (e.g. FULL("cell_type") )

-#' In case of single concatenation with no CONDITION or list with some value 

-#' without conditon, the metadata are considered having default 

-#' evaluation: the two attributes match if both end with value.

-#' 

-#' @param aggregates list of element in the form \emph{key} = \emph{aggregate}.

-#' The \emph{aggregate} is an object of class AGGREGATES

-#' The aggregate functions available are: \code{\link{SUM}}, 

-#' \code{\link{COUNT}}, \code{\link{MIN}}, \code{\link{MAX}}, 

-#' \code{\link{AVG}}, \code{\link{MEDIAN}}, \code{\link{STD}}, 

-#' \code{\link{BAG}}, \code{\link{BAGD}}, \code{\link{Q1}}, 

-#' \code{\link{Q2}}, \code{\link{Q3}}.

-#' Every aggregate accepts a string value, execet for COUNT, which does not 

-#' have any value.

-#' Argument of 'aggregate function' must exist in schema, i.e. among region 

-#' attributes. Two style are allowed:

-#' \itemize{

-#' \item list of key-value pairs: e.g. sum = SUM("pvalue")

-#' \item list of values: e.g. SUM("pvalue")

-#' }

-#' "mixed style" is not allowed

-#'

-#' @return DataSet class object. It contains the value to use as input 

-#' for the subsequent GMQL function

-#' 

-#' @seealso \code{\link{flat}} \code{\link{cover}} \code{\link{histogram}}

-#'

-#' @examples

-#'

-#' ## This GMQL statement computes the result grouping the input \emph{exp} 

-#' ## samples by the values of their \emph{cell} metadata attribute, 

-#' ## thus one output \emph{res} sample is generated for each cell type.

-#' ## Output regions are produced by extracting the highest accumulation 

-#' ## overlapping (sub)regions according to the methodologies described above;

-#'

-#'

-#' init_gmql()

-#' test_path <- system.file("example", "DATASET", package = "RGMQL")

-#' exp = read_dataset(test_path)

-#' res = summit(input_data = exp, 2, 4, c("cell"))

-#' 

-#' @export

-#'

-summit <- function(input_data, minAcc, maxAcc, groupBy = NULL,

-                    aggregates = NULL)

+gmql_cover <- function(input_data, minAcc, maxAcc, groupBy = NULL, 

+                            aggregates = NULL, variation)

 {

     minAcc <- .trasform_cover(deparse(substitute(minAcc)))

     maxAcc <- .trasform_cover(deparse(substitute(maxAcc)))

@@ -328,104 +157,9 @@ summit <- function(input_data, minAcc, maxAcc, groupBy = NULL,

     min <- .check_cover_param(minAcc,TRUE)

     max <- .check_cover_param(maxAcc,FALSE)

-    .doVariant("SUMMIT",minAcc,maxAcc,groupBy,aggregates,input_data)

-}

-

-#' GMQL Operation: FLAT

-#'

-#' returns the contiguous region that starts from the first end and stops at

-#' the last end of the regions which would contribute to each region 

-#' of the COVER

-#'

-#' @importFrom methods is

-#' @importFrom rJava J

-#' @importFrom rJava .jnull

-#' @importFrom rJava .jarray

-#' 

-#' @param input_data returned object from any GMQL function

-#' @param minAcc integer number representing minimum number of overlapping 

-#' regions to be considered during execution

-#' minAcc accept also:

-#' \itemize{

-#' \item{PARAMETER class object: \code{\link{ALL}} that represents the number 

-#' of samples in the input dataset}

-#' \item{and expression built using PARAMETER object: (ALL() + N) / K or

-#' ALL() / K }

-#' }

-#' @param maxAcc integer number representing maximum number of overlapping 

-#' regions to be considered during execution

-#' maxAcc accept also:

-#' \itemize{

-#' \item{PARAMETER class object: \code{\link{ALL}} that represents the number 

-#' of samples in the input dataset}

-#' \item{PARAMETER calss object: \code{\link{ANY}}} that acts as a wildcard, 

-#' considering any amount of overlapping.

-#' \item{and expression built using PARAMETER object: (ALL() + N) / K or

-#' ALL() / K }

-#' }

-#' @param groupBy list of CONDITION objects where every object contains 

-#' the name of metadata to be used in semijoin, or simple string concatenation 

-#' of name of metadata, e.g. c("cell_type", "attribute_tag", "size") 

-#' without declaring condition.

-#' The CONDITION's available are:

-#' \itemize{

-#' \item{\code{\link{FULL}}: Fullname evaluation, two attributes match 

-#' if they both end with value and, if they have a further prefixes,

-#' the two prefix sequence are identical}

-#' \item{\code{\link{EXACT}}: Exact evaluation, only attributes exactly 

-#' as value will match; no further prefixes are allowed. }

-#' }

-#' Every condition accepts only one string value. (e.g. FULL("cell_type") )

-#' In case of single concatenation with no CONDITION or list with some value 

-#' without conditon, the metadata are considered having default 

-#' evaluation: the two attributes match if both end with value.

-#' 

-#' @param aggregates list of element in the form \emph{key} = \emph{aggregate}.

-#' The \emph{aggregate} is an object of class AGGREGATES

-#' The aggregate functions available are: \code{\link{SUM}}, 

-#' \code{\link{COUNT}}, \code{\link{MIN}}, \code{\link{MAX}}, 

-#' \code{\link{AVG}}, \code{\link{MEDIAN}}, \code{\link{STD}}, 

-#' \code{\link{BAG}}, \code{\link{BAGD}}, \code{\link{Q1}}, 

-#' \code{\link{Q2}}, \code{\link{Q3}}.

-#' Every aggregate accepts a string value, execet for COUNT, which does not 

-#' have any value.

-#' Argument of 'aggregate function' must exist in schema, i.e. among region 

-#' attributes. Two style are allowed:

-#' \itemize{

-#' \item list of key-value pairs: e.g. sum = SUM("pvalue")

-#' \item list of values: e.g. SUM("pvalue")

-#' }

-#' "mixed style" is not allowed

-#'

-#' @return DataSet class object. It contains the value to use as input 

-#' for the subsequent GMQL function

-#' 

-#' @seealso \code{\link{summit}} \code{\link{cover}} \code{\link{histogram}}

-#'

-#' @examples

-#' 

-#' ## This GMQL statement computes the result grouping the input \emph{exp} 

-#' ## samples by the values of their \emph{cell} metadata attribute, 

-#' ## thus one output \emph{res} sample is generated for each cell type. 

-#' ## Output regions are produced by concatenating all regions which would 

-#' ## have been used to construct a COVER(2,4) statement on the same dataset; 

-#' 

-#' init_gmql()

-#' test_path <- system.file("example", "DATASET", package = "RGMQL")

-#' exp = read_dataset(test_path)

-#' res = flat(input_data = exp, 2, 4, c("cell"))

-#'

-#' @export

-#'

-flat <- function(input_data, minAcc, maxAcc, groupBy = NULL, aggregates = NULL)

-{

-    minAcc <- .trasform_cover(deparse(substitute(minAcc)))

-    maxAcc <- .trasform_cover(deparse(substitute(maxAcc)))

-    

-    min <- .check_cover_param(minAcc,TRUE)

-    max <- .check_cover_param(maxAcc,FALSE)

+    vary = toupper(variation)

-    .doVariant("FLAT",minAcc,maxAcc,groupBy,aggregates,input_data)

+    .doVariant(vary, minAcc, maxAcc, groupBy, aggregates, input_data)

 }

 .doVariant <- function(flag,minAcc,maxAcc,groupBy,aggregates,input_data)

@@ -445,21 +179,23 @@ flat <- function(input_data, minAcc, maxAcc, groupBy = NULL, aggregates = NULL)

     WrappeR <- J("it/polimi/genomics/r/Wrapper")

     response <- switch(flag,

                 "COVER" = WrappeR$cover(minAcc, maxAcc, join_condition_matrix,

-                                    metadata_matrix, input_data$value),

+                                    metadata_matrix, input_data),

                 "FLAT" = WrappeR$flat(minAcc, maxAcc, join_condition_matrix,

-                                    metadata_matrix,input_data$value),

+                                    metadata_matrix,input_data),

                 "SUMMIT" = WrappeR$summit(minAcc,maxAcc, join_condition_matrix,

-                                    metadata_matrix, input_data$value),

+                                    metadata_matrix, input_data),

                 "HISTOGRAM" = WrappeR$histogram(minAcc, maxAcc, 

                                 join_condition_matrix, metadata_matrix,

-                                input_data$value))

-

+                                input_data))

+    if(is.null(response))

+        stop("no admissible variation: cover, flat, summit, histogram")

+    

     error <- strtoi(response[1])

     data <- response[2]

     if(error!=0)

         stop(data)

     else

-        DataSet(data)

+        GMQLDataset(data)

 }

 .check_cover_param <- function(param,is_min)

@@ -1,7 +1,47 @@

-DataSet <- function(value)

-{

-    op_list <- list(value = value)

-    ## Set the name for the class

-    class(op_list) <- "DataSet"

-    return(op_list)

-}

\ No newline at end of file

+#'

+#' Abstract class representing GMQL dataset

+#' 

+#' @importClassesFrom S4Vectors DataTable

+#' 

+#' @name GMQLDataset-class

+#' @rdname GMQLDataset-class

+#' 

+setClass("GMQLDataset",

+            contains = c("DataTable"),

+            representation(value = "character"))

+

+# Constructor GMQLDataset

+GMQLDataset <- function(value) {

+    dataset <- new("GMQLDataset",value = value)

+    return(dataset)

+}

+    

+    

+setMethod("show", "GMQLDataset",

+            function(object)

+            {

+                cat("GMQL Dataset \n")

+                cat(" value :",paste(object@value))

+            })

+

+## insted of GMQL select

+setGeneric("filter", function(data, m_predicate = NULL, r_predicate = NULL, 

+                                semi_join = NULL, semi_join_negation = FALSE, 

+                                semi_join_dataset = NULL) 

+                            standardGeneric("filter"))

+

+## insted of GMQL extend

+setGeneric("mutate", function(.data, metadata = NULL) 

+                                standardGeneric("mutate"))

+

+# insted of GMQL order

+# setGeneric("sort", function(data, metadata_ordering = NULL, 

+# regions_ordering = NULL, fetch_opt = NULL, 

+# num_fetch = 0, reg_fetch_opt = NULL, 

+# reg_num_fetch = 0) standardGeneric("sort"))

+

+## insted of GMQL merge

+setGeneric("aggregate", function(data, groupBy = NULL) 

+                                    standardGeneric("aggregate"))

+

+

@@ -15,8 +15,8 @@

 #' @importFrom rJava .jnull

 #' @importFrom rJava .jarray

 #' 

-#' @param right_input_data returned object from any GMQL function

-#' @param left_input_data returned object from any GMQL function

+#' @param x returned object from any GMQL function

+#' @param y returned object from any GMQL function

 #' @param joinBy list of CONDITION objects where every object contains 

 #' the name of metadata to be used in semijoin, or simple string concatenation 

 #' of name of metadata, e.g. c("cell_type", "attribute_tag", "size") 

@@ -55,7 +55,7 @@

 #' test_path2 <- system.file("example", "DATASET_GDM", package = "RGMQL")

 #' r_left = read_dataset(test_path)

 #' r_right = read_dataset(test_path2)

-#' out = difference(r_left, r_right)

+#' out = setdiff(r_left, r_right)

 #' 

 #' \dontrun{

 #' ## This GMQL statement extracts for every pair of samples s1 in EXP1 

@@ -69,14 +69,23 @@

 #' test_path2 <- system.file("example", "DATASET_GDM", package = "RGMQL")

 #' exp1 = read_dataset(test_path)

 #' exp2 = read_dataset(test_path2)

-#' out = difference(exp1, exp2, c("antibody_target"))

+#' out = setdiff(exp1, exp2, c("antibody_target"))

 #'

 #' }

 #'

+#' @rdname setdiff-methods

+#' @aliases setdiff, GMQLDataset-methods

 #' @export

-#'

-difference <- function(left_input_data, right_input_data, joinBy = NULL, 

-                            is_exact = FALSE)

+setMethod("setdiff", c("GMQLDataset","GMQLDataset"),

+            function(x, y, joinBy = NULL, is_exact = FALSE)

+            {

+                val_x = x@value

+                val_y = y@value

+                gmql_difference(val_x, val_y, joinBy, is_exact)

+            })

+

+gmql_difference <- function(left_data, right_data, joinBy = NULL, 

+                                is_exact = FALSE)

 {

     if(!is.null(joinBy))

         join_condition_matrix <- .jarray(.join_condition(joinBy),

@@ -85,14 +94,13 @@ difference <- function(left_input_data, right_input_data, joinBy = NULL,

         join_condition_matrix <- .jnull("java/lang/String")

     WrappeR <- J("it/polimi/genomics/r/Wrapper")

-    response <- WrappeR$difference(join_condition_matrix,

-                                    right_input_data$value,

-                                    left_input_data$value,is_exact)

+    response <- WrappeR$difference(join_condition_matrix, right_data, 

+                                        left_data, is_exact)

     error <- strtoi(response[1])

     data <- response[2]

     if(error!=0)

         stop(data)

     else

-        DataSet(data)

+        GMQLDataset(data)

 }

@@ -9,7 +9,7 @@

 #' @importFrom rJava J

 #' @importFrom rJava .jarray

 #'

-#' @param input_data returned object from any GMQL function

+#' @param .data GMQLDataset class object 

 #' @param metadata list of element in the form \emph{key} = \emph{aggregate}.

 #' The \emph{aggregate} is an object of class AGGREGATES

 #' The aggregate functions available are: \code{\link{SUM}}, 

@@ -37,7 +37,7 @@

 #' init_gmql()

 #' test_path <- system.file("example", "DATASET", package = "RGMQL")

 #' r <- read_dataset(test_path)

-#' e <- extend(input_data = r, list(RegionCount = COUNT()))

+#' e <- mutate(input_data = r, list(RegionCount = COUNT()))

 #' 

 #' \dontrun{

 #' 

@@ -50,14 +50,24 @@

 #' init_gmql()

 #' test_path <- system.file("example", "DATASET", package = "RGMQL")

 #' exp = read_dataset(test_path)

-#' res = extend(input_data = exp, list(RegionCount = COUNT(),

+#' res = mutate(input_data = exp, list(RegionCount = COUNT(),

 #' MinP = MIN("pvalue")))

 #' 

 #' }

 #' 

+#' @name mutate

+#' @rdname mutate-methods

+#' @aliases mutate, GMQLDataset-methods

 #' @export

-#'

-extend <-function(input_data, metadata = NULL)

+setMethod("mutate", "GMQLDataset",

+            function(.data, metadata = NULL)

+            {

+                val_x = .data@value

+                gmql_extend(val_x, metadata)

+            })

+

+

+gmql_extend <-function(input_data, metadata = NULL)

 {

     if(!is.null(metadata))

         metadata_matrix <- .jarray(.aggregates(metadata,"META_AGGREGATES"),

@@ -66,12 +76,11 @@ extend <-function(input_data, metadata = NULL)

         metadata_matrix <- .jnull("java/lang/String")

     WrappeR <- J("it/polimi/genomics/r/Wrapper")

-    response <- WrappeR$extend(metadata_matrix,input_data$value)

+    response <- WrappeR$extend(metadata_matrix,input_data)

     error <- strtoi(response[1])

     data <- response[2]

     if(error!=0)

         stop(data)

     else

-        DataSet(data)

+        GMQLDataset(data)

 }

-

@@ -1,12 +1,19 @@

+#' @name join

+#' @rdname join-methods

+#' @aliases join

+#' @export

+setGeneric("join", function(x, y, by = NULL, ...) standardGeneric("join"))

+

+

 #' GMQL Operation: JOIN

 #'

 #' It takes in input two datasets, respectively known as nchor (left) 

 #' and experiment (right) and returns a dataset of samples consisting of 

 #' regions extracted from the operands according to the specified condition

-#' (a.k.a genometric_predicate).

+#' (a.k.a \emph{genometric_predicate}).

 #' The number of generated output samples is the Cartesian product 

 #' of the number of samples in the anchor and in the experiment dataset 

-#' (if joinBy is not specified).

+#' (if \emph{by} is not specified).

 #' The output metadata are the union of the input metadata, 

 #' with their attribute names prefixed with left or right respectively.

 #'

@@ -14,14 +21,14 @@

 #' @importFrom rJava J

 #' @importFrom rJava .jarray

 #' 

-#' @param left_input_data returned object from any GMQL function

-#' @param right_input_data returned object from any GMQL function

+#' @param x GMQLDataset class object

+#' @param y GMQLDataset class object

 #' @param genometric_predicate is a list of lists of DISTAL object

 #' For details of DISTAL objects see:

 #' \code{\link{DLE}}, \code{\link{DGE}}, \code{\link{DL}}, \code{\link{DG}},

 #' \code{\link{MD}}, \code{\link{UP}}, \code{\link{DOWN}}

 #' 

-#' @param joinBy list of CONDITION objects where every object contains 

+#' @param by list of CONDITION objects where every object contains 

 #' the name of metadata to be used in semijoin, or simple string concatenation 

 #' of name of metadata, e.g. c("cell_type", "attribute_tag", "size") 

 #' without declaring condition.

@@ -59,7 +66,7 @@

 #' the genometric predicate)}

 #' }

 #'

-#' @return DataSet class object. It contains the value to use as input 

+#' @return GMQLDataset class object. It contains the value to use as input 

 #' for the subsequent GMQL function

 #'

 #'

@@ -78,14 +85,26 @@

 #' TSS = read_dataset(test_path)

 #' HM = read_dataset(test_path2)

 #' join_data = join(TSS, HM, 

-#' genometric_predicate = list(list(MD(1), DLE(120000))), c("provider"), 

+#' genometric_predicate = list(list(MD(1), DLE(120000))), by = c("provider"), 

 #' region_output="RIGHT")

 #'

+#' @name join

+#' @rdname join-methods

+#' @aliases join, GMQLDataset-methods

 #' @export

-#'

-join <- function(right_input_data, left_input_data, 

-                    genometric_predicate = NULL, joinBy = NULL, 

+setMethod("join", "GMQLDataset",

+                function(x, y, by = NULL, genometric_predicate = NULL, 

                     region_output="contig")

+                {

+                    r_data <- x@value

+                    l_data <- y@value

+                    gmql_join(r_data, l_data, genometric_predicate, joinBy,