PHP download

PHP code example of sebastianguzmanmorla / lili-db

1. Go to this page and download the library: Download sebastianguzmanmorla/lili-db library. Choose the download type require.

2. Extract the ZIP file and open the index.php.

3. Add this code to the index.php.

    
        
<?php
require_once('vendor/autoload.php');

/* Start to develop here. Best regards https://php-download.com/ */

sebastianguzmanmorla / lili-db example snippets




use DateTime;
use LiliDb\Model;
use LiliDb\MySql\Attributes\Field as MySqlField;
use LiliDb\MySql\Attributes\Key as MySqlKey;
use LiliDb\MySql\Types\Numeric\DbBoolean as MySqlBoolean;
use LiliDb\MySql\Types\String\DbVarchar as MySqlVarchar;
use LiliDb\MySql\Types\Time\DbDateTime;
use LiliDb\PostgreSql\Attributes\Field as PostgreSqlField;
use LiliDb\PostgreSql\Attributes\Key as PostgreSqlKey;
use LiliDb\PostgreSql\Types\DbBoolean as PostgreBoolean;
use LiliDb\PostgreSql\Types\String\DbVarchar as PostgreSqlVarchar;
use LiliDb\PostgreSql\Types\Time\DbTimestamp;
use LiliDb\Token;

class TestTable
{
    use Model;

    #[MySqlKey(Name: 'Id')]
    #[PostgreSqlKey(Name: 'Id')]
    public ?int $TestId;

    #[MySqlField(Type: new MySqlVarchar(50), Name: 'Name', Default: 'Test')]
    #[PostgreSqlField(Type: new PostgreSqlVarchar(50), Name: 'TestName', Default: 'Test')]
    public ?string $TestName;

    #[MySqlField(Type: new DbDateTime(), Default: Token::DateTimeNow)]
    #[PostgreSqlField(Type: new DbTimestamp(), Default: Token::DateTimeNow)]
    public ?DateTime $TestDateTime;

    #[MySqlField(
        Name: 'State',
        Type: new MySqlBoolean(),
        Default: true,
    )]
    #[PostgreSqlField(
        Name: 'State',
        Type: new PostgreBoolean(),
        Default: true,
    )]
    public ?bool $State;
}




use TestTable;
use LiliDb\Database;
use LiliDb\Interfaces\ITable;
use LiliDb\MySql\Attributes\Table as MySqlTable;
use LiliDb\PostgreSql\Attributes\Table as PostgreSqlTable;

class TestDatabase extends Database
{
    #[MySqlTable(Model: TestTable::class, Name: 'A')]
    #[PostgreSqlTable(Model: TestTable::class, Schema: 'public', Name: 'TestTable')]
    public ITable $TestTable;
}




use TestDatabase;
use LiliDb\MySql\Connection as MySqlConnection;

$Connection = new MySqlConnection(
  Hostname: getenv('MYSQL_HOST'),
  Port: getenv('MYSQL_PORT'),
  Database: getenv('MYSQL_DATABASE'),
  Username: getenv('MYSQL_USERNAME'),
  Password: getenv('MYSQL_PASSWORD')
);

$Database = new TestDatabase($Connection, getenv('MYSQL_DATABASE'));




use TestDatabase;
use LiliDb\PostgreSql\Connection as PostgreSqlConnection;

$Connection = new PostgreSqlConnection(
  Hostname: getenv('POSTGRES_HOST'),
  Port: getenv('POSTGRES_PORT'),
  Database: getenv('POSTGRES_DATABASE'),
  Username: getenv('POSTGRES_USERNAME'),
  Password: getenv('POSTGRES_PASSWORD')
);

$Database = new TestDatabase($Connection, getenv('POSTGRES_DATABASE'));


foreach ($Database->DatabaseTables as $Table) {
  $CreateTable = $Table->CreateTable()
    ->ExecuteQuery();

  echo $CreateTable->Query;
}


$CreateTable = TestTable::CreateTable()
  ->ExecuteQuery();

echo $CreateTable->Query;


foreach ($Database->DatabaseTables as $Table) {
  $TruncateTable = $Table->TruncateTable()
    ->ExecuteQuery();

  echo $TruncateTable->Query;
}


$TruncateTable = TestTable::TruncateTable()
  ->ExecuteQuery();

echo $TruncateTable->Query;


foreach ($Database->DatabaseTables as $Table) {
  $DropTable = $Table->DropTable()
    ->ExecuteQuery();

  echo $DropTable->Query;
}


$DropTable = TestTable::DropTable()
  ->ExecuteQuery();

echo $DropTable->Query;


$Insert1 = TestTable::New(
    TestId: 1,
    TestName: 'a',
    TestDateTime: new DateTime(),
);

$Insert2 = new TestTable();
$Insert2->TestId = 2;
$Insert2->TestName = 'b';
$Insert2->TestDateTime = new DateTime();

$Insert = TestTable::Insert($Insert1, $Insert2)
    ->OnDuplicateKeyUpdate(fn(TestTable $x) =>
        $x->TestName &&
        $x->TestDateTime
    )
    ->Execute();

echo $Insert->Query;


$Update1 = new TestTable();
$Update1->TestName = 'a';
$Update1->TestDateTime = new DateTime();

$Update = TestTable::Update($Update1)
    ->Where(fn (TestTable $x) => $x->TestId == 1)
    ->Execute();

echo $Update->Query;


$Delete = TestTable::Delete()
    ->Where(fn (TestTable $x) => $x->TestId == 2)
    ->Execute();

echo $Delete->Query;


$Select = TestTable::InnerJoin(fn (TestTable2 $y, TestTable $x) => $y->TestId == $x->TestId && $y->Test2State)
  ->OrderBy(fn (TestTable $x) => $x->TestName)
  ->SelectField(TestTable::Field('TestId'), TestTable2::Field('Test2State'))
  ->SelectRaw('NOW() as Now')
  ->Execute();

foreach ($Select as $Item) {
  var_dump($Item);
}


$Select = TestTable::InnerJoin(fn (TestTable2 $y, TestTable $x) => $y->TestId == $x->TestId)
    ->Where(fn (TestTable $x) => $x->TestId > 0)
    ->Select(fn (TestTable2 $x): TestTable2 => $x)
    ->Execute();

foreach ($Select as $Item) {
    var_dump($Item);
}


use DateTime;

class TestSelect
{
    public function __construct(
        public ?int $TestId,
        public ?string $TestName,
        public ?DateTime $TestDateTime,
        public ?int $Test2Id,
        public ?int $Test2Number,
    ) {
    }
}


$Select = TestTable::InnerJoin(fn (TestTable2 $y, TestTable $x) => $y->TestId == $x->TestId)
    ->Where(fn (TestTable $x) => $x->TestId > 0)
    ->Select(fn (TestTable $x, TestTable2 $y): TestSelect => new TestSelect(
        TestId: $x->TestId,
        TestName: $x->TestName,
        TestDateTime: $x->TestDateTime,
        Test2Id: $y->Test2Id,
        Test2Number: $y->Test2Number
    ))
    ->Execute();

foreach ($Select as $Item) {
    var_dump($Item);
}



use LiliDb\OrderBy;
use LiliDb\Where;

$_GET['Test']['Test'] = true;

$Object = new TestTable2();
$Object->Test2State = false;

$value['Test']['Test'] = true;

$False = false;
$True = true;

$Like = 'a%';

$From = new DateTime();
$From->modify('-15 minutes');

$To = new DateTime();
$To->modify('+15 minutes');

$Select = TestTable
    ::LeftJoin(
        fn (TestTable2 $y, TestTable $x) => $y->TestId == $x->TestId || Where::Between($x->TestId, $y->Test2Number, $y->Test2Number)
    )
    ->Where(
        fn (TestTable $x, TestTable2 $y) => Where::Between($x->TestDateTime, $From, $To)
            || Where::Like($x->TestName, '%a%')
            || Where::NotLike($x->TestName, $Like)
            || Where::IsNull($y->Test2Number)
            || Where::IsNotNull($y->Test2Number)
            || Where::Between($y->Test2Number, 9, 12)
            || $y->Test2State == $value['Test']['Test']
            || $y->Test2State == $_GET['Test']['Test']
            || $y->Test2Number == 11
            || (
                $y->Test2State == $y->Test2State
                || $y->Test2State == $Object->Test2State
                || $y->Test2State == $False
                || $y->Test2State != false
                || $y->Test2State
                || !$y->Test2State
            )
    )
    ->OrderBy(fn (TestTable $x) => $x->TestName && OrderBy::Desc($x->TestDateTime))
    ->Select(fn (TestTable $x, TestTable2 $y): TestSelect => new TestSelect(
        TestId: $x->TestId,
        TestName: $x->TestName,
        TestDateTime: $x->TestDateTime,
        Test2Id: $y->Test2Id,
        Test2Number: $y->Test2Number
    ))
    ->ExecutePage(0, 1);

sql
SELECT
  `A`.`Id`,
  `B`.`D`,
  NOW() as Now
FROM `A`
INNER JOIN `B` ON `B`.`B` = `A`.`Id` AND `B`.`D` = TRUE
ORDER BY
  `A`.`Name`

sql
SELECT
  `A`.`Id`,
  `A`.`Name`,
  `A`.`TestDateTime`,
  `B`.`Id`,
  `B`.`C`
FROM
  `A`
LEFT JOIN `B` ON `B`.`B` = `A`.`Id` OR `A`.`Id` BETWEEN `B`.`C` AND `B`.`C`
WHERE
  (
    `A`.`TestDateTime` BETWEEN '2025-05-22 03:52:25' AND '2025-05-22 04:22:25'
    OR `A`.`Name` LIKE '%a%'
    OR `A`.`Name` NOT LIKE 'a%'
    OR `B`.`C` IS NULL
    OR `B`.`C` IS NOT NULL
    OR `B`.`C` BETWEEN 9 AND 12
    OR `B`.`D` = TRUE
    OR `B`.`D` = TRUE
    OR `B`.`C` = 11
    OR (
      `B`.`D` = `B`.`D`
      OR `B`.`D` = FALSE
      OR `B`.`D` = FALSE
      OR `B`.`D` <> FALSE
      OR `B`.`D` = TRUE
      OR `B`.`D` = FALSE
    )
  )
ORDER BY
  `A`.`Name`,
  `A`.`TestDateTime` DESC
LIMIT 0, 1

sql
SELECT
  "TestTable"."Id",
  "TestTable"."TestName",
  "TestTable"."TestDateTime",
  "TestTable2"."Test2Id",
  "TestTable2"."Test2Number"
FROM "public"."TestTable"
LEFT JOIN "public"."TestTable2" ON "TestTable2"."TestId" = "TestTable"."Id" OR "TestTable"."Id" BETWEEN "TestTable2"."Test2Number" AND "TestTable2"."Test2Number"
WHERE
  (
    "TestTable"."TestDateTime" BETWEEN '2025-05-22 03:52:25' AND '2025-05-22 04:22:25'
    OR "TestTable"."TestName" LIKE '%a%'
    OR "TestTable"."TestName" NOT LIKE 'a%'
    OR "TestTable2"."Test2Number" IS NULL
    OR "TestTable2"."Test2Number" IS NOT NULL
    OR "TestTable2"."Test2Number" BETWEEN 9 AND 12
    OR "TestTable2"."Test2State" = TRUE
    OR "TestTable2"."Test2State" = TRUE
    OR "TestTable2"."Test2Number" = 11
    OR (
      "TestTable2"."Test2State" = "TestTable2"."Test2State"
      OR "TestTable2"."Test2State" = FALSE
      OR "TestTable2"."Test2State" = FALSE
      OR "TestTable2"."Test2State" <> FALSE
      OR "TestTable2"."Test2State" = TRUE
      OR "TestTable2"."Test2State" = FALSE
    )
  )
ORDER BY
  "TestTable"."TestName",
  "TestTable"."TestDateTime" DESC
LIMIT
  1 OFFSET 0