Ferreteria/v0.6/clade/Sys/Data/Engine/schema/Ops/MyMar

clade: Sys\Data\Engine\schema\Ops\MyMar

Clade Family Ops ⇒ MyMar ⇒ (none) Clade Aliases Alias Clade Action* [c,i] Sys\Data\Engine\aux\msgs\Maria\ItWent Base* [c,i] Sys\Data\Engine\schema\Ops File* [c,i] Sys\FileSys\Node\Fi MBuffer* [c] IO\Aspect\Connx\Buffer\InMem Meta* [c] Sys\Data\aux\MetaPair RecvBuff* [c] IO\Aspect\Connx\Buffer\File\Writer SendBuff* [c] IO\Aspect\Connx\Buffer\File\Reader Subpages @fx/DoExport @fx/DoImport @removed

History

• 2025-06-01 moved from [WFe]Sys\Data\aux\Maria\*Schema ⇒ [WFe]Sys\Data\Engine\Schema\*MyMar
  • ...and later (October?), moved it again to Sys\Data\Engine\schema\Ops\*MyMar

Functions

• DoExport()
• DoImport()

Code

• @removed
• as of 2025-11-25:

interface iMyMar extends BaseIface {
    // inherited:
    # function DoExport(string $fsData) : ActionIface;
    # function DoImport(string $fsData) : ActionIface;
}
class cMyMar extends BaseClass implements iMyMar {
    // NOTE: This and Ops\MyMar::DoExport() are *both* used.
    public function DoExport(FileIface $ofData) : ActionIface {
        $oScrn = self::Screen();

        #echo $this->ReflectThis()->Report();
        $fsData = $ofData->Ident()->SpecFull();
        $oOper = $this->DbOper();
        $sSchema = $this->SchemaName();

        $ftSpec = $oScrn->GreenIt($fsData);
        $ftName = $oScrn->BoldIt($oScrn->BlueIt($sSchema));
        echo $oScrn->BoldIt(str_repeat('=',40)).CRLF;
        echo "Exporting $ftName to $ftSpec: ".CRLF;

        $ofMPair = MetaClass::FromDataSpec_wSchema($this,$fsData);
        #$ofMPair = MetaClass::FromDataSpec($fsData);
        #echo $ofMeta->DataFile()->ReflectThis()->Report();
        $oaMeta = $ofMPair->InfoFile()->InOut()->OAData();
        $oaMeta->DataFormat('SQL');
        #echo "META (".$oaMeta->ObjectID().") PRESETS 1:".CRLF.$oaMeta->Inspect()->Render().CRLF;
        $ofMPair->SaveStart();

        // ++ OUTPUT FILE: open it for buffering
        $oFile = FileClass::FromSpec($fsData);
        $oExecBuff = new RecvBuffClass($oFile);
        $oAct = $oExecBuff->Open();
        // -- OUTPUT FILE

        $oActBuff = NULL;
        if ($oAct->GetOkay()) {
            #echo $oOper->ReflectThis()->Report();
            $oAct = $oOper->DoExport($sSchema,$oExecBuff);
            $oAct->HandleResults();
            #echo ' ' . ($oAct->GetOkay() ? $oScrn->GreenIt('Done.') : $oScrn->ErrorIt('Error:')) . CRLF;
        } else {
            $sMsg = $oScrn->ErrorIt('Error').': Could not open output buffer.'.CRLF.$oAct->GetStatusText().CRLF;
            $oAct->AddMsgString($sMsg);
        }
        $oActBuff = $oExecBuff->Shut(); // displays final status report and closes the buffer
        $ofMPair->SaveFinish($oAct);
        echo $oAct->RenderMessages();   // should go *after* buffer->Shut() so final message is on same line as earlier ones

        return $oAct;
    }
    /**
     * ACTION: import SQL data via command-line
     * TODO 2025-02-11 There really should be a log.
     */
    public function DoImport(FileIface $ofData, bool $okToReplace) : ActionIface {
        $oScrn = self::Screen();

        $oAct = new ActionClass;

        #echo $this->ReflectThis()->Report();
        $sSchema = $this->QSchemaName()->GetIt();
        $oDBC = $this->DbConn();
          // 2025-06-05 TODO: get this from the Creds object now --
        $sCreds = $oDBC->CredsForCmd(); // db (inside) connection string

        #echo $ofData->Ident()->ReflectThis()->Report();
        $fsData = $ofData->Ident()->SpecFull();
        $ftFile = $oScrn->BlueIt($fsData);
        $ftSchema = $oScrn->GreenIt($sSchema);

        $this->AmHere("CHECKING EXISTENCE OF SCHEMA [$ftSchema]");

        // Check to see if schema already exists
        if ($oDBC->OOper()->SchemaExists($sSchema)) {
            echo $oScrn->InfoIt('Found')." schema [$ftSchema]...".CRLF;

            #echo $this->ReflectThis()->Report();
            if ($okToReplace) {
                $sCmd = "echo 'CREATE OR REPLACE DATABASE $sSchema;' | mysql $sCreds";
                echo $oScrn->GreenIt('Replacing')." schema [$sSch]...".CRLF;
                $oAct->SetOkay(TRUE);   // ok to proceed
            } else {
                echo $oScrn->YellowIt('Schema already exists').' -- use "replace" if you want to erase the existing data.'.CRLF;
                $oAct->SetOkay(FALSE);  // can't proceed
            }

            // Should also work: "DROP..." and then "CREATE..."
        } else {
            #echo $oScrn->GreenIt('Plan').": create schema [$ftSchema] and import data from [$ftFile].".CRLF;
            echo $oScrn->GreenIt('Creating')." schema [$sSchema]...".CRLF;
            $sCmd = "echo 'CREATE DATABASE `$sSchema`;' | mysql $sCreds";
            // NOTE: $sSchema without backticks will work *unless* the schema name contains "-".
            $oAct->SetOkay(TRUE);   // ok to proceed
        }

        if ($oAct->GetOkay()) {
            // create buffer for sending commands:
            $oReplyBuff = new MBufferClass; // buffer for brief replies (not for file-storage)
            $oAct = $oReplyBuff->Open();

            // ** FIRST: create/replace the database as determined earlier

            #echo $this->ReflectThis()->Report();  // how do we get the DbConn object?
            $oDbConn = $this->DbConn();
            $oConnx = $oDbConn->OSock();
            #echo $oConnx->ReflectThis()->Report();  // how do we get the DbConn object?
            #echo $oDbConn->ReflectThis()->Report(); // need to change Action Class returned by DoCommand()
            $oAct = $oDbConn->DoCommand($sCmd,$oReplyBuff);
            if ($oAct->GetOkay()) {

                // ** AND THEN: import the data

                echo $oScrn->InfoIt('Importing')." from file [$ftFile]...".CRLF;

                // This version expects the data to be sent separately, and should also work remotely.
                $sCmd = "mysql $sCreds -D$sSchema";

                // Send command to open connection to receive data:
                #echo $oConnx->OPlug()->ReflectThis()->Report();
                $oProc = $oConnx->OPlug()->OpenProcess($sCmd);
                // create buffer for import data
                #$ofData = FileClass::FromSpec($fsData);
                $oSendBuff = new SendBuffClass($ofData);
                #$oProc->SetSendBuff($oDataBuff);   // no need when using SendFromBuffer, I think?
                // open data file for read-buffering:
                // send file's data:
                $oProc->SendFromBuffer($oSendBuff,$oReplyBuff);
                echo 'Buffer sent.'.CRLF;
                $oProc->Shut();
            } else {
                echo $oScrn->ErrorIt('Problem').": command to create the schema '$sSchema' did not succeed.".CRLF.$oAct->GetStatusText().CRLF;
            }

            #echo $oAct->ReflectThis()->Report();
            $oAct = $oDbConn->WrapAction($oAct);  // TODO: This is *coming* from DbConn -- shouldn't it already be properly wrapped?
            #echo $oDbConn->ReflectThis()->Report();
            $oAct->HandleResults();
            echo $oAct->RenderMessages();
        } else {
            $sMsg = $oScrn->ErrorIt('Error').': Could not open output buffer.'.CRLF.$oAct->GetStatusText().CRLF;
            $oAct->AddMsgString($sMsg);
            $oAct->SetOkay(FALSE);
        }

        if ($oAct->GetOkay()) {
            $ftMsg = $oScrn->GreenIt('Ok!').' - Restore complete.'.CRLF;
            $oAct->AddMsgString($ftMsg);
        }
        return $oAct;
    }
}