head

C<DSL::English::DataQueryWorkflows> package has grammar and action classes for the parsing
and interpretation of natural language commands that specify data queries in the style of
Standard Query Language (SQL) or RStudio's library tidyverse.


use DSL::English::DataQueryWorkflows;
my $rcode = ToDataQueryWorkflowCode("select height & mass; arrange by height descending");



unit module DSL::English::DataQueryWorkflows;

use DSL::Shared::Utilities::MetaSpecsProcessing;
use DSL::Shared::Utilities::CommandProcessing;

use DSL::English::DataQueryWorkflows::Grammar;

use DSL::English::DataQueryWorkflows::Actions::Julia::DataFrames;
use DSL::English::DataQueryWorkflows::Actions::Python::pandas;
use DSL::English::DataQueryWorkflows::Actions::R::base;
use DSL::English::DataQueryWorkflows::Actions::R::tidyverse;
use DSL::English::DataQueryWorkflows::Actions::Raku::Reshapers;
use DSL::English::DataQueryWorkflows::Actions::SQL::Standard;
use DSL::English::DataQueryWorkflows::Actions::WL::System;

use DSL::English::DataQueryWorkflows::Actions::Bulgarian::Standard;
use DSL::English::DataQueryWorkflows::Actions::English::Standard;
use DSL::English::DataQueryWorkflows::Actions::Korean::Standard;
use DSL::English::DataQueryWorkflows::Actions::Russian::Standard;
use DSL::English::DataQueryWorkflows::Actions::Spanish::Standard;

#-----------------------------------------------------------

my %targetToAction{Str} =
    "Bulgarian"         => DSL::English::DataQueryWorkflows::Actions::Bulgarian::Standard,
    "English"           => DSL::English::DataQueryWorkflows::Actions::English::Standard,
    "Julia"             => DSL::English::DataQueryWorkflows::Actions::Julia::DataFrames,
    "Julia-DataFrames"  => DSL::English::DataQueryWorkflows::Actions::Julia::DataFrames,
    "Korean"            => DSL::English::DataQueryWorkflows::Actions::Korean::Standard,
    "Mathematica"       => DSL::English::DataQueryWorkflows::Actions::WL::System,
    "Python"            => DSL::English::DataQueryWorkflows::Actions::Python::pandas,
    "Python-pandas"     => DSL::English::DataQueryWorkflows::Actions::Python::pandas,
    "R"                 => DSL::English::DataQueryWorkflows::Actions::R::base,
    "R-base"            => DSL::English::DataQueryWorkflows::Actions::R::base,
    "R-tidyverse"       => DSL::English::DataQueryWorkflows::Actions::R::tidyverse,
    "Raku"              => DSL::English::DataQueryWorkflows::Actions::Raku::Reshapers,
    "Raku-Reshapers"    => DSL::English::DataQueryWorkflows::Actions::Raku::Reshapers,
    "Russian"           => DSL::English::DataQueryWorkflows::Actions::Russian::Standard,
    "SQL"               => DSL::English::DataQueryWorkflows::Actions::SQL::Standard,
    "Spanish"           => DSL::English::DataQueryWorkflows::Actions::Spanish::Standard,
    "WL"                => DSL::English::DataQueryWorkflows::Actions::WL::System,
    "WL-System"         => DSL::English::DataQueryWorkflows::Actions::WL::System,
    "pandas"            => DSL::English::DataQueryWorkflows::Actions::Python::pandas,
    "tidyverse"         => DSL::English::DataQueryWorkflows::Actions::R::tidyverse;

my %targetToAction2{Str} = %targetToAction.grep({ $_.key.contains('-') }).map({ $_.key.subst('-', '::') => $_.value }).Hash;
%targetToAction = |%targetToAction , |%targetToAction2;


my Str %targetToSeparator{Str} =
    "Bulgarian"         => "\n",
    "English"           => "\n",
    "Julia"             => "\n",
    "Julia-DataFrames"  => "\n",
    "Korean"            => "\n",
    "Mathematica"       => "\n",
    "Python"            => "\n",
    "Python-pandas"     => "\n",
    "R"                 => " ;\n",
    "R-base"            => " ;\n",
    "R-tidyverse"       => " %>%\n",
    "Raku"              => " ;\n",
    "Raku-Reshapers"    => " ;\n",
    "Russian"           => "\n",
    "SQL"               => ";\n",
    "Spanish"           => "\n",
    "WL"                => ";\n",
    "WL-System"         => ";\n",
    "pandas"            => ".\n",
    "tidyverse"         => " %>%\n";

my Str %targetToSeparator2{Str} = %targetToSeparator.grep({ $_.key.contains('-') }).map({ $_.key.subst('-', '::') => $_.value }).Hash;
%targetToSeparator = |%targetToSeparator , |%targetToSeparator2;


#-----------------------------------------------------------
sub has-semicolon (Str $word) {
    return defined index $word, ';';
}

#-----------------------------------------------------------
proto ToDataQueryWorkflowCode(Str $command, | ) is export {*}

multi ToDataQueryWorkflowCode( Str $command, :$target = 'R-tidyverse', *%args ) {
    return ToDataQueryWorkflowCode( $command, $target, |%args);
}

multi ToDataQueryWorkflowCode( Str $command, Str $target = 'R-tidyverse', *%args ) {

    my $lang = %args<language>:exists ?? %args<language> !! 'English';
    $lang = $lang.wordcase;

    my $gname = "DSL::{$lang}::DataQueryWorkflows::Grammar";

    try require ::($gname);
    if ::($gname) ~~ Failure { die "Failed to load the grammar $gname." }

    my Grammar $grammar = ::($gname);

    # Not needed, just showing that :$language is otherwise passed to ToWorkflowCode.
    # %args = %args.pairs.grep({ $_.key ne 'language' }).Hash;

    DSL::Shared::Utilities::CommandProcessing::ToWorkflowCode( $command,
                                                               :$grammar,
                                                               :%targetToAction,
                                                               :%targetToSeparator,
                                                               :$target,
                                                               |%args )
}


multi ToDataQueryWorkflowCode ( Str $command where has-semicolon($command), Str $target where $_ eq 'SQL', *%args ) {

    my $specTarget = get-dsl-spec( $command, 'target');

    $specTarget = $specTarget ?? $specTarget<DSLTARGET> !! $target;

    die 'Unknown target.' unless %targetToAction{$specTarget}:exists;

    # Note that this is global, class variable.
    # It is put to {} here in order to able track group-by statements in WL-System and R-base.
    my $actionsObj =  %targetToAction{$target}.new;
    $actionsObj.properties = {};

    my @commandLines = $command.trim.split(/ ';' \s* /);

    @commandLines = grep { $_.Str.chars > 0 }, @commandLines;

    #my @cmdLines = map { ToDataQueryWorkflowCode($_, $specTarget) }, @commandLines;
    my @cmdLines = map { ToWorkflowCode($_, grammar => DSL::English::DataQueryWorkflows::Grammar, actions => $actionsObj, separator => %targetToSeparator{$specTarget}, format => 'hash') }, @commandLines;
    @cmdLines = @cmdLines.map({ $_.first({ $_.key !eq 'CODE' }) });

    #@cmdLines = grep { $_.^name eq 'Str' }, @cmdLines;

    say @cmdLines.raku;

    my %sqlLines = @cmdLines;

    return @cmdLines.join( %targetToSeparator{$target} ).trim;
}

#-----------------------------------------------------------
proto to_DataQuery_Julia($) is export {*}

multi to_DataQuery_Julia ( Str $command ) {
    return ToDataQueryWorkflowCode( $command, 'Julia-DataFrames' );
}

#-----------------------------------------------------------
proto to_DataQuery_tidyverse($) is export {*}

multi to_DataQuery_tidyverse ( Str $command ) {
    return ToDataQueryWorkflowCode( $command, 'R-tidyverse' );
}

#-----------------------------------------------------------
proto to_DataQuery_pandas($) is export {*}

multi to_DataQuery_pandas ( Str $command ) {
    return ToDataQueryWorkflowCode( $command, 'Python-pandas' );
}

#-----------------------------------------------------------
proto to_DataQuery_WL(Str $) is export {*}

multi to_DataQuery_WL ( Str $command ) {
    return ToDataQueryWorkflowCode( $command, 'WL-System' );
}

#-----------------------------------------------------------
proto to-data-query-raku-code($) is export {*}

multi to-data-query-raku-code ( Str $command ) {
    return ToDataQueryWorkflowCode( $command, 'Raku::Reshapers' );
}


root

Standard

README

React

=begin React :component<HeaderCol> :id<menu> 
=para L<Documentation|/doc/introduction>
=para L<Modules| /mods>
=para L<Examples| file:../examples/index.podlite>
=para L<Download |file:../download/index.podlite>
=para L<About|file:../about/index.podlite>
=para 🔍 K<⌘K>/K<ctrl-K>
=end React


=begin React :component<HeaderCol> :id<footer>  
=begin nested :!nested
=item1 B<Language>
    =item2 L<Get started|file:../getting-started/getting-started.podlite>
    =item2 L<Why Raku?|/doc/language/faq#Why-should-I-learn-Raku-What's-so-great-about-it>
    =item2 L<Try Raku|https://glot.io/new/raku>
    =item2 L<Raku cheat sheet|https://github.com/Raku/mu/blob/master/docs/Perl6/Cheatsheet/cheatsheet.txt>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<Raku on Exercism|https://exercism.org/tracks/raku>
    =item2 L<Wikipedia|https://en.wikipedia.org/wiki/Raku_(programming_language)>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>

=end nested
=begin nested :!nested

=item1 B<L<Documentation|/doc>>
    =item2 L<Getting started, Migration guides from other languages, & Tutorials | file:../doc/introduction.podlite>
    =item2 L<Language References|file:../doc/reference.podlite>
    =item2 L<Type Reference| file:../doc/types.podlite>
    =item2 L<Miscellaneous| file:../doc/miscellaneous.podlite>
    =item2 L<FAQs (Frequently Asked Questions)|/doc/language/faq>
    =item2 L<Community|/doc/language/community>
    =item2 L<The list of all documents|file:../doc/index.podlite>

=item1 B<Resources>
    =item2 L<The Raku Guide|https://raku.guide/>
    =item2 L<Books |https://perl6book.com/>
    =item2 L<Rosetta Code | https://www.raku.org/community/rosettacode>

=end nested
=begin nested :!nested

=item1 B<Resoures>
    =item2 L<Download | file:../download/index.podlite>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>

=item1 B<Learning>
    =item2 L<The Raku Guide|https://raku.guide/>
    =item2 L<Wikibook |https://en.wikibooks.org/wiki/Raku_Programming>
    =item2 L<Books |https://perl6book.com/>
    =item2 L<Rosetta Code | https://www.raku.org/community/rosettacode>
    =item2 L<Learn Raku in Y minutes|https://learnxinyminutes.com/docs/raku/>
    =item2 L<Golfing |https://github.com/AlexDaniel/raku-golf-cheatsheet>
=end nested
=begin nested :!nested

=item1 B<Explore>
    =item2 L<Raku Blog Aggregator|https://planet.raku.org/>
    =item2 L<Rakudo Weekly|https://rakudoweekly.blog/>
    =item2 L<The Weekly Challenge |https://perlweeklychallenge.org/>
    =item2 L<Raku Advent Calendar|https://raku-advent.blog/>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>

=end nested
=end React


=begin React :component<CookieConsent> :id<CookieConsent> :buttonCaption("Got it!")
=para
This website uses cookies for analytics.
=end React


DataQueryWorkflows

DSL::English::DataQueryWorkflows

Synopsis

DSL::English::DataQueryWorkflows v0.5.6

Authors

License

Dependencies

Test Dependencies

Provides

Documentation