para

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::Raku::SQL::Builder;
use DSL::English::DataQueryWorkflows::Actions::SQL::SQLite;
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,
    "Raku-SQL"          => DSL::English::DataQueryWorkflows::Actions::Raku::SQL::Builder,
    "Raku-SQLBuilder"   => DSL::English::DataQueryWorkflows::Actions::Raku::SQL::Builder,
    "Raku-SQL-Builder"  => DSL::English::DataQueryWorkflows::Actions::Raku::SQL::Builder,
    "Russian"           => DSL::English::DataQueryWorkflows::Actions::Russian::Standard,
    "SQL"               => DSL::English::DataQueryWorkflows::Actions::SQL::Standard,
    "SQL-Standard"      => DSL::English::DataQueryWorkflows::Actions::SQL::Standard,
    "SQLite"            => DSL::English::DataQueryWorkflows::Actions::SQL::SQLite,
    "SQL-SQLite"        => DSL::English::DataQueryWorkflows::Actions::SQL::SQLite,
    "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('-', '::', :g) => $_.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",
    "Raku-SQL"          => '.',
    "Raku-SQLBuilder"   => ".",
    "Raku-SQL-Builder"  => '.',
    "Russian"           => "\n",
    "SQL"               => "\n",
    "SQL-Standard"      => "\n",
    "Spanish"           => "\n",
    "WL"                => ";\n",
    "WL-System"         => ";\n",
    "pandas"            => "\n.",
    "tidyverse"         => " %>%\n";

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


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

#-----------------------------------------------------------
#| Translates natural language commands into data query DSL code.
#| * C<$command> is a string with one or many commands (separated by ';').
#| * C<$target> is a programming-language-and-package name, like <R-tidyverse Raku::Reshapers Python::pandas>; or a natural language one of <Bulgarian English Korean Russian Spanish>.
#| * C<:$format> is the format of the output, one of <code hash raku>.
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,
                                Str $target where $_ ∈ <SQL SQL::Standard SQL-Standard SQLite SQL-SQLite SQL::SQLite>,
                                *%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 @sqlLines = map { ToDataQueryWorkflowCode($_, $specTarget) }, @commandLines;
    my @sqlLines = @commandLines.map({
        ToWorkflowCode($_,
                grammar => DSL::English::DataQueryWorkflows::Grammar,
                actions => $actionsObj,
                separator => %targetToSeparator{$specTarget},
                format => 'hash')
    });

    my @sqlParts = @sqlLines.map({ $_.first({ $_.key !eq 'CODE' }) });

    if @sqlParts.all ~~ Pair:D {
        @sqlParts = DSL::English::DataQueryWorkflows::Actions::SQL::Standard.combine-sql-parts(@sqlParts);
        return @sqlParts.join(%targetToSeparator{$target}).trim;
    } elsif !( @sqlLines.elems == 1 && (@sqlLines.head<CODE>:exists) && @sqlLines.head<CODE>.trim) {
        note "Cannot parse ⎡$command⎦.";
        return Nil;
    } else {
        return @sqlLines.map({ $_<CODE> // Empty }).join("\n");
    }
}

#-----------------------------------------------------------
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' );
}

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

#| Shortcut for ToDataQueryWorkflowCode($cmd, "Raku::Reshapers")
proto to-data-query-raku-code($) is export {*}

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


root

README-work

Standard-data-wrangling-commands

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<AI|file:../mcp/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<Download | file:../download/index.podlite>
    =item2 L<Raku cheat sheet|https://github.com/Raku/mu/blob/master/docs/Perl6/Cheatsheet/cheatsheet.txt>
    =item2 L<Raku on Exercism|https://exercism.org/tracks/raku>
    =item2 L<Wikipedia|https://en.wikipedia.org/wiki/Raku_(programming_language)>

=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>
    =item2 L<Hand these documents to an AI assistant|file:../mcp/index.podlite>

=end nested
=begin nested :!nested
=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/>

=end nested
=end React


Built with L<Podlite|https://podlite.org> — the markup and publishing tools behind this site.


=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.6.5

Authors

License

Dependencies

Test Dependencies

Provides

Documentation