Base de données shucan sq1 documentation de référence 0.2.3

Aperçu

La plus petite unité de fonctionnement prise en charge par une base de données shucan est une table, c'est-à-dire qu'il n'y a pas de concept de bibliothèque;La base de données shucan est basée sur le stockage en colonnes et prend en charge les types de structure de données de base C++,comprendintégralité(comprend u08、i08、u16、i16、u32、i32、u64、i64)、virgule flottante(comprend float、double)、chaîne de caractères de longueur fixe(comprend string04、string08、string16、string32、string64、string128、string256)、 type de date(date)、type d'heure(time)、type de datetime(datetime)。

Tout champ de la base de données sur le shucan implique un index basé sur un arbre équilibré, comme détaillécreate phrase,l'export dans la sql phrase etload phraseouimport phraseprend en charge l'exportation et l'importation de tables.
Note: Langage de requête de base de données shucan(ci-après abrégé en sql),similaire au langage de requête standard (ci-après abrégé en SQL),la structure syntaxique de base est compatible,globalprocessusnon compatible SQL。

Notez que les méthodes d’opération sql suivantes diffèrent de SQL standard:

  • Shucan sql utilise == pour indiquer l’égalité
  • L’instruction sql where de shucan ne prend en charge que le jugement d'intervalle de plage, voirwhere description de la condition
  • Le paramètre interne du nombre de shucan sql ne prend pas en charge *, la partie expression ne prend en charge qu’un * séparé
  • La base de données shucan ne prend pas en charge les valeurs null
  • Fonctionnalités prises en charge par la base de données shucan:

  • Prend en charge les sous-requêtes sql et les requêtes multitables
  • Prend en charge du plus haut niveau de transactions
  • Prend en charge de la correspondance floue de caractères et de la correspondance d'expression régulière
  • Prend en charge l’encodage complet des caractères utf8(unique)
  • Bon formulaire d'opération de l'interface du langage C
  • Prend en charge la persistance externe et l'échange csv
  • Prend en charge des systèmes Windows, Linux
  • Prend en charge de plusieurs modes de réseau local et réseau
  • Configuration requise pour l'installation

    La base de données shucan utilise une certaine quantité de mémoire comme cache. Vous pouvez configurer la mémoire cache pour différentes tables, et il est recommandé que le système conserve au moins 2G de mémoire pendant l'installation. Nous vous recommandons de réserver au moins 10 Go d'espace disque disponible sur le disque où se trouve le répertoire d'installation dans le répertoire sdb.

    Configuration système requise

    La base de données shucan fonctionne correctement sur les systèmes d'exploitation suivants:
    Windows 7,Windows 10,Windows server 2008 et supérieur,Linux Debian 9,Linux Centos 7. Les autres systèmes de distribution n'ont pas été entièrement testés, veuillez vous assurer de l'environnement système ci-dessus lors de l'installation.

    Si la colonne de données de la base de données shucan est multiple, assurez-vous que le nombre maximal de fichiers ouverts sur le système de Linux est supérieur aux exigences de la colonne de données.

    Contraintes d'utilisation de la base de données

    Le nombre maximal de tables prises en charge par la base de données shucan est de 4096, le nombre maximal de champs par table est de 4096 et la longueur maximale de chaque champ est de 256.
    Les noms de champs peuvent être limités par des caractères pris en charge par le système, à utiliser pour s’assurer que les noms de champs sont des noms de fichiers valides.

    Le fichier de configuration de la base de données shucan et les données d’importation et d’exportation (y compris les phrases sql ou les fichiers csv) sont tous codés utf8 par défaut, avec des sauts de ligne système Unix comme fin de ligne.

    La correspondance de retour n’est pas prise en charge .* dans la correspondance d’expression régulière de shucan.

    La plate-forme Linux par défaut a un nombre maximum de liens réseau simultanés de 16.

    Installation et fonctionnement du système

    La plate-forme Windows peut extraire directement le fichier de package d’installation zip que vous avez acheté dans le répertoire cible.

    La plate-forme Linux peut extraire directement le fichier du package d’installation gz que vous avez acheté dans le répertoire cible.

    Composition du système

    Composition du répertoire système Windows

    Version locale de l’exécutable sct_local.exe
    Programme exécutable côté serveur sct_s.exe
    Programme exécutable côté client sct_c.exe
    Kits de développement Web sdk
    Version locale du fichier de configuration sct_ldb.toml
    Profil réseau sct_rdb.toml
    Les fichiers de données se trouvent dans le répertoire sdb

    Composition du répertoire système Linux

    Version locale de l’exécutable run_l.sh
    Programme exécutable côté serveur run_s.sh
    Programme exécutable côté client run_c.sh
    Kits de développement Web sdk
    Version locale du fichier de configuration sct_ldb.toml
    Profil réseau sct_rdb.toml
    Les fichiers de données se trouvent dans le répertoire sdb

    Mode de démarrage

    Le mode local exécute directement la version locale de l’exécutable ; Après être entré dans l’environnement d’exécution, entrez la commande «help» pour afficher les informations d’aide ou entrez directement la phrase sql à exécuter, la spécification sql correspondante est décrite dans leconseil rapide sqlsection.

    Les clients en mode réseau en cours d’exécution doivent spécifier un nom d’utilisateur, un mot de passe et un port IP facultatif. Voici un exemple d’exécution valide.
    sct_c.exe user user_pwd
    sct_c.exe user user_pwd 192.168.1.11 55555

    La stratégie d’authentification en mode réseau par défaut est que le nom d’utilisateur et le mot de passe doivent être spécifiés pour la première connexion, 3 erreurs s’arrêtent pendant 1 minute, 2 erreurs s’arrêtent pendant 30 minutes, 1 erreur s’arrête pendant 15 jours et 1 erreur est définitivement bloquée jusqu’à ce que le service soit redémarré.

    Configuration du système

    La base de données shucan utilise toml comme fichier de configuration, le mode local utilise sct_ldb.toml comme fichier de configuration, la spécification du fichier toml est détaillée dansspécifications connexes, le max_cache_level dans le fichier de configuration est le paramètre d’utilisation de la mémoire cache le plus important, en particulier les performances de lecture, il indique le nombre de couches de cache de l’arborescence BST, le minimum est 0, indiquant qu’aucune mémoire n’est utilisée

    Le paramètre auto_cache indique si les données du cache sont automatiquement chargées au démarrage de la base de données, la valeur par défaut est automatiquement mise en cache, la auto_cache_ratio indique le rapport de hauteur d’arborescence maximale du cache, 0 indique qu’il n’y a pas de cache du tout et 1 indique le cache complet. Notez que la mise en cache prendra un certain temps et qu’il est recommandé de ne pas mettre en cache des proportions de hauteur trop importantes pour les tables de données volumineuses.

    Le paramètre cache_table définit la taille du cache pour un nom de table particulier.

    big_csv Le champ big_csv indique external_sort_count le nombre de lignes à la fois lors de l’utilisation de la commande load big_csv et csv_read_once_size indique la taille de fichier d’une lecture csv en même temps. Pour les machines avec une petite mémoire physique, les paramètres correspondants peuvent être ajustés plus petit, plus le paramètre est grand, plus l’exécution de la commande de charge est rapide.

    Le serveur en mode réseau est sct_s.exe et le serveur utilise sct_rdb.toml comme fichier de configuration, et le contenu de configuration est lié aux informations de port et de groupe d’utilisateurs, et les autres informations de configuration du cache sont identiques au contenu de configuration de la base de données en mode local.

    enable_write_cache indique si la mise en cache des écritures est activée, si la mise en cache en écriture n’est pas activée par défaut et si l’utilisation de la mise en cache en écriture peut accélérer efficacement l’insertion, la mise à jour et la suppression des données, mais la perte de données peut être provoquée lorsque le service est anormalement fermé.

    write_cache_count représente le nombre maximal de caches d’écriture pour chaque champ, plus le nombre est grand, plus l’opération d’écriture est rapide, et il est recommandé de ne pas trop volumineux pour les données. Les champs ci-dessus peuvent être omis par défaut, et si la configuration correspondante n’existe pas, les valeurs des paramètres de configuration par défaut sont utilisées.

    Spécification sql shucan

    Description de la spécification sql Foundation

    Les phrases sql sont composées de DDL, DML, DML se cpmpose de selectinsertdeleteupdaterows_ofcols_offields_ofshow tablesetc; DDL se cpmpose de createalterdropimportloadexecetc.
    Chaque expression ou contenu de commentaire non constant d’instruction sql peut être suivi d’un nombre quelconque de caractères vides ou de commentaires, des espaces blancs sont 0x09 à 0x0c (notez que les espaces blancs ne contiennent pas de 0x0d, ce qui signifie que la fin de la ligne d’exécution de la phrase sql est par défaut au format unix) ou 0x20 caractères ASCII.
    Toutes les phrases sql sont strictement sensibles à la casse et le codage de caractères est unique UTF-8.
    Chaque terminaison de phrase sql est « ; » , la terminaison peut être omise sans affecter l’analyse des phrases.

    exégèse

    exégèses d’une seule ligne:
    //Ceci est une exégèse

    exégèses multilignes:
    /*Ceci est une
    exégèse
    */

    Le type de données sous-jacent

    Entier

    0                      //entiers signés ou non signés
    1                      //Entier omet le symbole
    100                    //Entier omet le symbole
    +1                     //Entier signé
    -100                   //Entier signé
    -1000                  //Entier signé
    +0b000                 //Entier binaire signé
    -0xa0b3                //Entier hexadécimal signé
    0xA0cD                 //Casse non signée mélangeant des entiers hexadécimaux
    -847u2                 //Entier signé de deux octets
    56u1                   //Entier non signé d’un octet
    0x0au1                 //Entier hexadécimal non signé d’un octet

    Nombre à virgule flottante

    +0.                    //Nombre à virgule flottante positive sans partie décimale
    -0.01                  //Seules les parties fractionnaires sont des nombres à virgule flottante négatifs
    -100.0                 //Seules les parties entières sont des nombres à virgule flottante négatifs
    -100e20                //Seuls les entiers et les exposants positifs sont des nombres à virgule flottante négatifs
    1.25E-32               //Nombres à virgule flottante positifs en parties exponentielles décimales et négatives
    1.25E+20               //Nombres à virgule flottante positifs en parties exponentielles décimales et positives
    1.00E20f               //Nombre strict à virgule flottante de quatre octets
    1.00E20d               //Nombre strict à virgule flottante de huit octets

    Une chaîne de caractères de longueur fixe

    Les chaînes de longueur fixe ne prennent en charge que les longueurs d’octets suivantes:4,8,16,32,64,128,256
    
    "a et chinois bc"                            //Chaînes valides en anglais et en chinois (codage UTF-8)
    "ab et chinois c\"\'\\\a\b\f\n\r\t\v"        //Contient des chaînes valides qui contrôlent l’échappement
    "ab et chinois c\x0a\x0001\uaabb\Uaabbccdd"  //Contient des chaînes valides pour l’échappement hexadécimal et l’échappement Unicode
    @"aabbcc(018d7##@!@^_""AA6)aabbcc"    //La chaîne d’origine divisée par aabbcc

    Type de date

    2020-02-03                              //3 février 2020
    0020-01-31                              //31 janvier 2020

    Type d'heure

    18:59:31                                 //18:59:31
    00:00:01.100                             //0:0:1.1

    Type de datetime

    2020-02-03 18:59:31.123                  //18:59:31.123 3 février 2020

    L'expression

    L'expression utilise la structure de base de l'expression en langage C et la priorité du symbole d'opérateur correspondant est réservée.
    
    id                           //L’expression de domaine représente la valeur de champ correspondante
    (id)                         //L’expression entre parenthèses indique la priorité de l’évaluation du contenu entre parenthèses
    id+10                        //L’expression additive représente la somme du champ de domaine avec la valeur constante 10
    id+max(grade)                //L’expression additive représente la somme de la valeur maximale du champ de domaine et du champ de grade
    id*sin(id)                   //L’expression de produit représente le produit de la valeur sin du domaine id et du domaine id
    id << 10                     //L’expression shift représente la valeur du décalage vers la gauche du champ id de 10 bits
    id&&sin(id)>0                //La logique et l’expression représentent la logique et le résultat de id et sin(id)>0
    id/sin(id)                   //L’expression intégrative représente le quotient de id et sin(id).
    id&min(id)                   //Le bit et l’expression représentent les bits id et min(id) et le résultat
    id!=0||id==10                //Une logique ou une expression représente une logique ou un résultat où id n’est pas égal à 0 et id est égal à 10
    
    La conversion des types d’expression et la gestion des fonctions suivent ces instructions
    Si le type de données peut être implicitement converti en type cible selon le langage C++, il est implicitement converti en type cible selon C++.
    Le processus de traitement de la fonction est le suivant : si le paramètre de fonction est un champ, la fonction agit sur la valeur de chaque ligne du champ, si le paramètre de fonction est une valeur constante, la valeur constante est utilisée comme paramètre de fonction,
    si le nombre de lignes des deux paramètres n’est pas égal, le plus grand nombre de lignes est utilisé comme résultat de sortie et le paramètre le plus court est rempli à longueur égale avec le dernier bit en continu.

    Peut être utilisé pour les fonctions dans les expressions

    La fonction est suivie d’une explication de la fonction et d’un exemple d’utilisation
    
    Fonctions de conversion de type
    x2i08                 //Tout type de données est converti en entier signé sur un octet          x2i08(type), x2i08(2.0)
    x2i16                 //Tout type de données est converti en entier signé sur deux octets          x2i16(type), x2i16(2.0)
    x2i32                 //Tout type de données est converti en entier signé sur quatre octets          x2i32(type), x2i32(2.0)
    x2i64                 //Tout type de données est converti en entier signé sur huit octets          x2i64(type), x2i64(2.0)
    x2u08                 //Tout type de données est converti en entier non signé d’un octet          x2u08(type), x2u08(2.0)
    x2u16                 //Tout type de données est converti en entier non signé de deux octets          x2u16(type), x2u16(2.0)
    x2u32                 //Tout type de données est converti en entier non signé de quatre octets          x2u32(type), x2u32(2.0)
    x2u64                 //Tout type de données est converti en entier non signé de huit octets         x2u64(type), x2u64(2.0)
    x2flt                 //Tout type de données est converti en un nombre à virgule flottante de quatre octets             x2flt(id), x2flt(10)
    x2dbl                 //Tout type de données est converti en un nombre à virgule flottante de huit octets             x2dbl(id), x2dbl(10)
    x2str04               //Tout type de données est converti en chaîne de quatre octets             x2str04(id), x2str04(10)
    x2str08               //Tout type de données est converti en chaîne de huit octets             x2str08(id), x2str08(10)
    x2str16               //Tout type de données est converti en chaîne de seize octets           x2str16(id), x2str16(10)
    x2str32               //Tout type de données est converti en chaîne de trente-deux octets          x2str32(id), x2str32(10)
    x2str64               //Tout type de données est converti en chaîne de soixante-quatre octets        x2str64(id), x2str64(10)
    x2str128              //Tout type de données est converti en chaîne de cent vingt-huit octets       x2str128(id), x2str128(10)
    x2str256              //Tout type de données est converti en chaîne de deux cent cinquante-six octets       x2str256(id), x2str256(10)
    x2date                //Tout type de données est converti en date                    x2date(b_date),x2date("2012-03-05")
    x2time                //Tout type de données est converti en temps                    x2time(b_time),x2time("18:35:24")
    x2datetime            //Tout type de données est converti en datetime                x2datetime(b_dt),x2datetime("2012-03-05 18:35:24")
    
    Fonctions d’agrégation
    sum                   //Trouver la somme d’une colonne                          sum(id), sum(1.0)
    product               //Trouver le produit d’une colonne                            product(id), product(1.0)
    min                   //Rechercher la valeur minimale d’une colonne                         min(id), min(1.0)
    max                   //Rechercher la valeur maximale d’une colonne                         max(id), max(1.0)
    avg                   //Rechercher la moyenne d’une colonne                           avg(id), avg(1.0)
    count                 //Rechercher le nombre total de colonnes                           count(id), count(1.0)
    sort                  //Trier une colonne                               sort(id)
    unique                //Dédupliquer une colonne                             unique(sort(id))
    count_unique          //Obtenir le numéro après la déduplication                         count_unique(sort(id))
    
    Fonction de plage
    first                 //Prendre le premier élément d’une colonne                      first(id)
    last                  //Prendre le dernier élément d’une colonne                    last(id)
    first_k               //Prendre les k premiers éléments d’une colonne                       first_k(id,10)
    last_k                //Prendre les k derniers éléments d’une colonne                     last_k(id,20)
    range                 //Prendre les éléments d’une colonne                       range(id,1,5)
    nth                   //Prendre le nième élément d’une colonne                       nth(id,10)
    
    Fonctions de chaîne
    lcase                 //Convertir les chaînes en minuscules                       lcase("Abd")
    ucase                 //Convertir les chaînes en majuscules                       ucase("abc")
    concat                //Concaténer deux chaînes                         concat("abc","012")
    length                //Trouver la longueur de la chaîne                           length("NAME")
    substr                //Prendre la chaîne de l’index à un nombre fixe de sous-chaînes      substr(name, 1, 4)
    all_case              //Obtenir toutes les chaînes de combinaison de casse                 all_case("Insert")
    starts                //Déterminer si la chaîne commence par une chaîne                 starts(name, "Jim")
    contain               //Déterminer si la chaîne contient une cible                   contain(desc, "error")
    ends                  //Déterminer si la chaîne contient une cible                 ends(word, "es")
    replace               //Remplacer la sous-chaîne de la chaîne par une nouvelle chaîne                 replace(name, 2, 4, "abc")
    trim_l                //Déplacer les espaces consécutifs à gauche de la chaîne                   trim_l(name)
    trim_r                //Déplacer les espaces consécutifs à droite de la chaîne                   trim_r(name)
    trim                  //Déplacer les espaces consécutifs des deux côtés de la chaîne                   trim(name)
    reg_match             //Correspondance d’expressions régulières(Utiliser la norme ECMA-262(2011))   reg_match(id,"[2-9]+.*")
    fuzzy_match           //Récupération floue des différences de caractères correspondantes              fuzzy_match(id,"what"),fuzzy_match(type,"system", 5)
    
    Fonctions mathématiques
    abs                   //Rechercher la valeur absolue de la valeur                        abs(value)
    ceil                  //Rechercher le plus petit entier dont la valeur n’est pas inférieure à la valeur donnée            ceil(value)
    floor                 //Rechercher le plus grand entier dont la valeur n’est pas supérieure à la valeur donnée            floor(value)
    round                 //Arrondir la valeur                      round(3.4)
    exp                   //Trouver l'exponent fixe du nombre e                        exp(value)
    pow                   //Trouver l'exponent de la valeur                            pow(id,2.0)
    pi                    //Valeur constante π                              pi()
    sqrt                  //Trouver le carré ouvert de la valeur                         sqrt(value)
    log                   //Trouver le logarithme naturel d’une valeur                       log(value)
    log2                  //Trouver le logarithme en base 2 de la valeur est calculé                      log2(value)
    log10                 //Trouver le logarithme en base 10 de la valeur est calculé                     log10(value)
    log1p                 //Trouver le logarithme népérien de la valeur +1                     log1p(value)
    sin                   //Trouver la valeur de la sinusoïde de la valeur                         sin(value)
    cos                   //Trouver la valeur du cosinus de la valeur                         cos(value)
    tan                   //Trouver la valeur de la tangente de la valeur                         tan(value)
    asin                  //Trouver la valeur de l'arcsine de la valeur                       asin(value)
    acos                  //Trouver la valeur de l'arccosine de la valeur                       acos(value)
    atan                  //Trouver la valeur de l'arctangent de la valeur                       atan(value)
    e                     //Constante mathématique e                             e()
    
    Fonctions intrinsèques
    raw2hex               //Affichage hexadécimal de la mémoire                       raw2hex(id)
    row_id                //Sortie du numéro de ligne                              row_id()
    id                    //Sortie de l’id interne                           id()
    now_id                //Obtenir le plus grand id inutilisé à l’intérieur                  now_id()
    hash_passwd           //Générer un mot de passe de hash pour une chaîne (pour les fichiers de configuration)      hash_passwd("mypass")
    
    Fonctions statistiques
    var                   //écart de sortie                             var(id)
    stddev                //écart type                               stddev(id)
    
    Fonctions de séquence
    seq                   //Séquences de sortie 0 à n                        seq(10), seq(count(id)), seq(3)*3
    rand                  //Sortie n 0 à 1,0 nombres aléatoires                 rand(10)
    constants             //Sortie n constantes                         constants(1,10), constants("sss",10)
    
    Fonctions de date
    last_day              //Renvoyer le dernier jour de la date mois             last_day(date())
    is_leap               //Renvoyer s’il s’agit d’une année bissextile                    is_leap(date())
    now                   //Renvoyer la date et l’heure actuelle.                   now()
    date                  //Renvoyer la date actuelle                       date()
    time                  //Renvoyer l’heure actuelle                      time()
    add_day               //Renvoyer l’heure ou la datetime après n jours          add_day(now(),100)
    add_nanosec           //Renvoyer l’heure ou la datetime après n nanosecondes        add_nanosec(time(),10000000)
    sub_day               //Renvoyer l’heure ou la datetime avant n jours          sub_day(now(),100)
    sub_nanosec           //Renvoyer l’heure ou la datetime avant n nanosecondes        sub_nanosec(time(),10000000)
    day_diff              //Renvoyer la différence en jour entre la date ou la datetime         day_diff(x2date("2012-01-01"),date())
    nanosec_diff          //Renvoyer la différence en nanosecondes entre l’heure ou la date        nanosec_diff(x2time("18:24:25"),time())
    year_of               //Renvoyer la partie année d’une date ou d’une heure          year_of(date())
    month_of              //Renvoyer la partie mois de la date ou de l’heure          month_of(date())
    day_of                //Renvoyer la partie jour de la date ou de l’heure          day_of(date())
    hour_of               //Renvoyer la partie heure de l’heure ou de la datetime          hour_of(time())
    minute_of             //Renvoyer la partie minute de l’heure ou de la datetime         minute_of(time())
    second_of             //Renvoyer la partie seconde de l’heure ou de la datetime          second_of(time())
    nanosec_of            //Renvoyer la partie nanoseconde de l’heure ou de la datetime         nanosec_of(time())
    date_of               //Renvoyer la partie date de la datetime              date_of(now())
    time_of               //Renvoyer la partie heure de la datetime              time_of(now())
    weekday               //Renvoyer le jour de la semaine pour la date ou l’heure (0 est lundi)     weekday(now())
    weekday_name          //Renvoyer le nom du jour de la semaine pour la date ou l'heure          weekday_name(now())
    weekday_cname         //Renvoyer le nom chinois du jour de la date ou de l’heure       weekday_cname(now())

    La condition where permet l’utilisation d’opérations relationnelles, de plage, de in et logiques

    L’expression where est différente du flux de traitement du SQL standard, où la partie condition représente uniquement une instruction conditionnelle qui peut être utilisée pour extraire directement de la table de données et où l’opération complexe correspondante doit être effectuée à l’aide du post-traitement des données. Ce traitement permet de déterminer plus clairement si une instruction sql utilise des conditions d’index et le post-traitement.

    id>=10                           //Supérieur ou égal aux opérations logiques
    id>=all (select id from t2)      //Opération logique supérieure ou égale à tous les résultats d’une sous-requête
    id==any (select id from t2)      //Opération logique égale à n’importe quel résultat d’une sous-requête
    id==any (1,3,5,7)                //Opération logique égale à n’importe quel résultat d’un ensemble
    id==10                           //Égal aux opérations logiques
    id!=10                           //Non égal aux opérations logiques
    id>=10&&id<=20                   //Logique et opérations entre opérations relationnelles
    id>=10||(id < 5&& id > 1)        //Logique et opérations entre opérations relationnelles
    10 <= id <= 20                   //Inférieur à égal et inférieur à égal aux opérations relationnelles
    10 < id <= 20                    //Inférieur et inférieur à égal aux opérations relationnelles
    
    first                            //La première des opérations de gamme
    last                             //La dernière des opérations de gamme
    first 100                        //Les 100 premières opérations de gamme
    last 100                         //Les 100 dernières opérations de gamme
    range 10 100                     //Opérations de gamme de 10 à 100
    nth 10                           //Le numéro du 10ème de l’opération de gamme
    id max                           //La plus grande des opérations de la plage de valeurs
    id min                           //La plus petite des opérations de la plage de valeurs
    id max 100                       //Le top 100 maximal des opérations de plage de valeurs
    id min 100                       //Le top 100 minimal des opérations de plage de valeurs 
    
    id in (1,2,3,4,7)                //L’opération en IN prend l’id avec les id 1, 2, 3, 4, 7
    id in (select id from t2);       //Retirer l’id à la suite de la sous-expression
    id not in (select id from t2);   //Retirer l’id n’est pas un résultat dans la sous-expression
    
        
        Notez que la condition suivante est une condition where non valide
        10 < id                          //L’id du nom du champ doit être placé en premier

    Processus de requête sql

    Le stockage réel des données est en colonnes

    Méthode de stockage

    Le processus de traitement des données de la base de données sur le shucan est le suivant:

    Le contenu de la phrase where doit être une condition de recherche qui utilise un index (différent des instructions SQL standard) et applique la condition pour filtrer les lignes de données.

    Les informations de ligne extraient le contenu de la colonne et évaluent l’expression pour produire le jeu de données.

    Les jeux de données peuvent être mis à l’échelle horizontalement et verticalement (join/union) pour un jeu de données unique plus grand.

    Un seul ensemble effectue le tri, le filtrage, le regroupement, l’agrégation, la projection, le changement de nom et le recalcul de plusieurs post-opérations.

    trier

    Il existe cinq types de filtrage:

    Filtrage en ligne

    Filtrage interligne, complexité n*n

    Filtrage des voisins

    Filtrage de plage de lignes

    Filtrage de présence/sous-requête

    Agrégations groupées

    projection

    renommer

    recalculer

    Phrase Select

    Sélectionnez la définition de grammaire partielle psg (EBNF-like)

    select * from table1;
    //Sélectionnez tous les champs dans la table1
    
    select id from tab2;
    //Sélectionnez le champ id dans la tab2
    
    select id /sin(id) from tab2 where id < 10;
    //Dans la tab2, sélectionnez les données d’ID dont l’ID est inférieur à 10 et divisez l’ID par la valeur de sin(id).
    
    select max(id) from tab2 where id < 10&&id > 3;
    //Dans la tab2, sélectionnez le plus grand ID supérieur à 3 et inférieur à 10
    
    select id << 10 from tab2 where id!=3
    //Sélectionnez l’ID dans la tab2 avec un ID égal à 3 et déplacez-le de 10 chiffres vers la gauche
    
    select sin(id),name into t2 from t1 where id < 10;
    //Sélectionnez ID inférieur à 10 à partir de t1, insérez t2 avec sin(id) et nommez sous forme de colonnes
    
    select * from t1 where id in (select id2 from t2 where id2 > 10);
    //Sélectionnez tout t1 dans t1 lorsque ID est dans t2 lorsque ID2 est supérieur à 10 et ID2 dans ID2
    
    select * from t1 where id < 10 order by id, name asc;
    //Sélectionnez-les tous dans t1, lorsque l’id est inférieur à 10, puis classez le dictionnaire dans l’ordre croissant par id et nom
    
    select * from t1 where id < 10 group sum(id) by name;
    //Sélectionnez-les tous dans t1 lorsque l’ID est inférieur à 10, puis utilisez name pour regrouper sum(id)
    
    select * from t1 where id < 10 all_each on distinct;
    //Sélectionnez toutes les lignes de t1 lorsque l’ID est inférieur à 10 et filtrez toutes les lignes à dédupliquer
    
    select * from t1 where id < 10 all_each on id==_id && name==_name;
    //Sélectionnez toutes les données de t1 lorsque id est inférieur à 10 et filtrez toutes les lignes avec le même id et le même nom, _ représente chacun des ensembles précédents
    
    select * from t1 where id < 10 adj on id>_id && name==_name;
    //Sélectionnez toutes les données de t1 lorsque l’ID est inférieur à 10, puis filtrez l’ID de voisin de ligne supérieur à l’ID précédent et identique à Nom, _ représente la ligne précédente
    
    select * from t1 where id < 10 inner on id==name;
    //Sélectionnez toutes les données avec ID et nom dans la ligne lorsque les ID sont inférieurs à 10 à partir de t1
    
    select * from t1 where id < 10 first;
    //Après avoir sélectionné tout dans t1, lorsque l’ID est inférieur à 10, filtrez et conservez la première ligne
    
    select * from t1 where id < 10 first 30;
    //Sélectionnez tout dans t1 lorsque l’ID inférieur à 10 est filtré pour conserver les 30 premières lignes
    
    select * from t1 where id < 10 range 30 40;
    //Sélectionnez parmi t1 lorsque l’ID est inférieur à 10 pour filtrer les données dans la plage de 30 à 40 lignes
    
    select id1,name from t1 where id < 10 exists (select id from t2 where id==id1);
    //Sélectionnez l’ID est inférieur à 10 dans t1 et nom présents dans t2 
    
    select id as nid,name from t1 where id < 10 not exists (select id from t2 where id==nid);
    //À partir de t1, nid et name avec id égal à nid égal à nid ne sont pas présents lorsque id est inférieur à 10 et qu’il n’y a pas d’id égal à nid dans t2
    
    select * from t1 where id < 10 recompute id=id+10;
    //À partir de t1, sélectionnez-les tous lorsque l’ID est inférieur à 10 et recalculez que l’ID est égal à ID plus 10
    
    select * from t1 where id < 10 recompute id+=10,name=x2str(id);
    //Sélectionnez-les tous dans t1 lorsque l’id est inférieur à 10 et recalculez l’ID de colonne égal à id plus 10 et le nom égal à l’ID converti en chaîne
    
    select * from t1 where id < 10 project except id;
    //Sélectionnez toutes les post-projections de t1 lorsque id est inférieur à 10 pour conserver les données de colonne sauf id
    
    select * from t1 where id < 10 project id;
    //Sélectionnez tous les ID de colonne de rétention post-projection de t1 lorsque l’ID est inférieur à 10
    
    select * from t1 where id < 10 rename id newid;
    //Sélectionnez-les tous dans t1 lorsque l’ID est inférieur à 10 et renommez l’ID en Newid
    
    select * from t1 where id < 10 project id range 30 40 group sum(id) by id order by id rand rename id newid;
    //Sélectionnez tous les ID de post-projection de t1 lorsque les ID sont inférieurs à 10, filtrez les données dans la plage de 30 à 40, regroupez sum(id) avec id, triez aléatoirement par ID et renommez l’ID en newid
    
    select * from t1 where id1 < 10 join (select * from t2 where id2 < 10 on id1==id2);
    //Sélectionnez tout à partir de t1, lorsque ID1 est inférieur à 10, puis mettez à l’échelle horizontalement pour tout sélectionner à partir de T2, et lorsque ID2 est inférieur à 10, lorsque ID1 est égal à ID2
    
    select sin(seq(count(id))+1), id, name from t1 where id < 10 union (select * from t2 where id < 10);
    //Sélectionnez à partir de t1 lorsque l’ID est inférieur à 10 sin(seq(count(id)+1), id, extension verticale de nom à partir de t2 sélectionnez tous les ID inférieurs à 10
    
    select sin(id) as sinid,id from t1 where id < 10 inner on sinid < id;
    //Dans t1, sélectionnez le sin(id) lorsque l’ID est inférieur à 10 comme filtre sinid et ID, et conservez les données avec le sinid inférieur à l’ID de la ligne
    
    select * from t1 export as csv split by "," path = "t1.csv";
    //Sélectionnez tous les champs de t1 à exporter vers un fichier de t1.csv  séparé par des virgules

    Insert phrase

    insert into tab1 (name,id) values("Zhangsan",100);                      //Insertion unique
    insert into tab2 (val,type)values(1.00,1)(2.00,2)(3.00,3);          //Inserts multiples
    insert into t2 (id,name) select id,name from t1;                    //Insérer les résultats de la sous-requête
    insert into t2 (id,name) select seq(10)+1,"name"+x2str(seq(10)+1);  //Insérer des données personnalisées
    
    Notez que les bases de données shucan ne prennent pas en charge les champs nuls,donc insert doit spécifier une valeur pour chaque champ

    Delete phrase

    delete from tab1 where id < 10;                       //Supprimer toutes les données dont l’ID est inférieur à 10 de tab1

    Update phrase

    update tab1 set name="Zhangsan",id=10 where id==5;
    //Mettez à jour le champ de nom avec ID égal à 5 dans la tab1 à Zhangsan, et ID est 10

    Create phrase

    create table tab1 (id u08 (false, false));
    //Créez une tab1, le champ initial est un entier non signé d’un octet de type id et la duplication n’est pas autorisée
    
    create table tab1 (val float(),name string08(true));
    //Créer une tab1, le champ initial val est en virgule flottante, aucune duplication n’est autorisée et le champ de name est string et permet la répétition
    
    Notez que le deuxième paramètre du champ courant est un paramètre réservé et que l’utilisation réelle n’a aucun effet

    Alter phrase

    alter table tab1 add id u08 (false, false);          //Ajouter le champ id à tab1
    alter table tab1 modify id u08 (false, false);       //Dans la tab1, modifiez le type de champ id, la modification effacera les données de champ précédentes, veuillez les sauvegarder
    alter table tab1 rename id newid;                    //Dans tab1, renommez le champ id en newid
    alter table tab1 drop id;                            //Supprimer le champ id dans tab1

    Drop phrase

    drop table tab1                        //Supprimer la tab1

    Truncate phrase

    truncate table t1;                     //Vider rapidement t1 et préserver les structures de données

    Import phrase

    import csv/csvs La commande fournit la fonction d’importation de données (la signification csv / csvs est la même que load), lisez une ligne à la fois insert
    import conserve le contenu de la table d’origine, vitesse lente, journal à chaque fois.
    
    Notez : La table doit exister lors de l’utilisation de l’import.
    
    import t1 from csv split by "\t" path="t1.csv"    //Importez le t1.csv dans t1 avec \t comme délimiteur
    import t1 from csvs path="t1.csvs"                //Importez t1.csvs dans t1 (chaîne de représentation de fichier csvs convertie en code ASCII 16 caractères de base)

    Load phrase

    La base de données shucan utilise csv/csvs comme fichier d’échange. Les fichiers cav/csvs commencent par \n comme fin de ligne et par une virgule (,) comme séparateur par défaut ; La première ligne est le nom du champ, 
    et tous les autres caractères sont contenu du champ. Le nombre de champs est le même, sinon des erreurs de cohérence des données peuvent en résulter. Contrairement aux csv généraux, les chaînes csv/csvs de shucan n’ont pas besoin de guillemets doubles.
    Le fichier csvs convertit les champs de la chaîne en chaîne hexadécimale ascii correspondante (fonction raw2hex). Utilisé pour éviter les chaînes avec des \n des séparateurs.
    load big_csv/big_csvs/csv/csvs charge le fichier approprié. Le chargement csv/csvs lit directement toutes les lignes de fichier pour assurer une mémoire suffisante.
    load big_csv/big_csvs lit environ csv_read_once_size lignes entières de taille à chaque fois, extrait les données correspondantes pour générer des données de champ individuelles, puis utilise l’explication.
    et enfin générez directement des données. Convient aux fichiers particulièrement gourmands en données. Les fichiers temporaires avec les noms de fichiers suivants sont générés pendant le processus de génération (en supposant que id est un nom de champ et que le nom de fichier est w.csv):
        id_from_csv_w.csv
        id_from_csv_w.csv_with_row_id
        id_from_csv_w.csv_with_row_id_sorted
        id_from_csv_w.csv__with_row_id_sorted_svt
        id_from_csv_w.csv_for_index
        id_from_csv_w.csv_for_index_sorted 
        id_from_csv_w.csv_for_index_sorted_svt
    Le fichier suivant est généré pour l’écoulement:
        0,1,2,3,4,.., merging_file
    Assurez-vous que le répertoire du programme ne contient pas ces fichiers et assurez-vous qu’une certaine quantité de mémoire (environ 2G) est disponible.
    La différence entre load et import:
        load ne conserve pas le contenu de la table d’origine, import conserve le contenu de la table d’origine
        load construit directement la structure sous-jacente sans journalisation; import insère les données strictement en fonction du processus
        load est plus rapide et adapté aux migrations de données volumineuses, import convient aux petites quantités de données
    
    Notez: La table doit exister lors de l’utilisation de load
    
    load t1 from csv split by "\t" path="t1.csv"       //Importer le t1.csv dans t1 avec \t comme délimiteur
    load t1 from csvs path="t1.csvs"                   //Importer t1.csvs dans t1 (chaîne de représentation de fichier csvs convertie en code ASCII 16 caractères de base)
    load t1 from big_csv split by "\t" path="t1.csv"   //Importer le t1.csv dans t1 avec \t comme délimiteur
    load t1 from big_csvs path="t1.csvs"               //Importer t1.csvs dans t1

    Nom du champ

    Le nombre maximal de noms de champs de la base de données shucan est de 256 caractères et le nombre maximal de champs dans chaque table est de 4096
    Notez: Lors de l’enregistrement des noms de champs en tant que fichiers locaux, ils sont limités par le nom du fichier système et certains caractères spéciaux ou noms de fichiers spéciaux peuvent ne pas être pris en charge.
    
    abc
    abc0123
    ABC_abc
    [Chaînes non-@ valides (voir chaînes)]

    Nom de la table

    Le nom de table maximal de la base de données shucan est de 256 caractères, et le nombre maximal de tables dans chaque base de données est de 4096
    Notez: Lors de l’enregistrement d’un nom de table en tant que fichier local, il est limité par le nom du fichier système et certains caractères spéciaux ou noms de fichiers spéciaux peuvent ne pas être pris en charge.
    
    abc
    abc0123
    ABC_abc
    [Chaînes non-@ valides (voir chaînes)]

    Rows_of

    rows_of tab1            //Obtenir le nombre de lignes dans tab1

    Cols_of

    cols_of tab1            //Obtenir le nombre de colonnes  dans tab1

    Fields_of

    fields_of tab1          //Obtenir le nom de champ dans tab1

    Show tables

    show tables             //Obtenir tous les noms de table dans la base de données

    Exec

    exec "data.sql"         //Exécuter toutes les phrases du fichier sql

    Atom_exec

    atom_exec insert into t1 (id,name) select 1,"sss";delete from t1; commit
    //Exécution transactionnelle de plusieurs éléments se terminant par « ; » est l’instruction d’intervalle, de commit terminée (le niveau d’isolement est le niveau le plus élevé, en termes simples, tous réussissent ou tous échouent, 
    seul insert, update, deleteest sont pris en charge)

    Recommandations d’optimisation

    La base de données shucan utilise BST comme index, et les résultats de la requête sont construits à travers l’arbre BST pour récupérer des données pour chaque requête de colonne, ce qui est très approprié pour les requêtes d’intervalle de petite plage. Le contenu de l’instruction where est le premier niveau de conditions de filtrage des conditions de recherche, qui est la partie la plus importante qui détermine le nombre de lignes de sortie, et les conditions de requête doivent donner la priorité à la garantie que la partie where est entièrement filtrée.

    a est préférable lors de l’interrogation de la condition where <=id <=b Au lieu de la condition de requête sous la forme id>= a&&id <=b la première sera directement complétée à l’aide de l’algorithme d’intervalle interne, et la seconde interrogera les deux parties de l’intervalle séparément pour l’opération d’intersection définie.

    La condition where prime sur l’opération &&,essayez d’éviter d’utiliser || opérations logiques.

    Essayez de ne pas utiliser l’expression != pour la condition where.

    Utilisez de préférence rows_of obtenir le nombre de lignes de la table, au lieu du champ count.

    Pour les données valides faibles dans les tables de données volumineuses, le filtrage in des requêtes est prioritaire pour le filtrage initial.

    Pour les ensembles de données volumineux, plusieurs données valides peuvent être filtrées à l’aide de conditions exists.

    Lorsque sql est analysé, l’arborescence syntaxique après l’analyse est mise en cache et il est recommandé de fusionner autant que possible les phrases d’insert pour éviter une analyse multiple.

    La phrase Where est utilisée de préférence pour filtrer le jeu de données et le traitement post-opération du jeu de données est réduit.

    L’évaluation des expressions de phrases sql est plus lente que le langage C, essayez d’éviter d’utiliser un grand nombre de traitements d’expressions; un grand nombre de traitements d’expressions peuvent être retraités en C après l’obtention de l’expression d’analyse.

    Lors de l’importation de grandes quantités de données, la directive load big_csv est préférée, la phrase load csv est utilisée secondairement et la phrase import est utilisée en dernier, et les phrases exec et insert ne sont pas utilisées autant que possible.

    Instructions de développement

    La base de données shucan est écrite en C++, et le côté réseau fournit une interface en langage C/C++/Java (y compris JDBC)/Python encapsulée, et la bibliothèque de développement se trouve dans le répertoire sdk.

    Les bibliothèques de liens dynamiques sont disponibles dans le package d’installation et se trouvent dans le répertoire sdk. Les fichiers d’en-tête se trouvent dans le répertoire sdk/inc.

    Les fonctions de base incluent la connexion, la sortie du serveur, l’exécution d’instructions sql et l’obtention d’informations sur les lignes et les colonnes et les valeurs du jeu de données.Voici un exemple complet d’interface du langage C(位于sdk/sql_lib_sample.c):

    #include <stdlib.h>
    #include <stdio.h>
    #include "sql_lib.h"
    
    void print_bymyself(void* d) {
    
        int r = rows_of(d);
        int c = cols_of(d);
        printf("\n");
        for (size_t i = 0; i < c; ++i) {
          int s = 0;
          const char* n = col_name(&s, d, i);
          printf("%.*s ", s, n);
        }
        printf("\n");
        for (size_t i = 0; i < r; ++i) {
          for (size_t j = 0; j < c; ++j) {
            void* v = at(i, j, d);
            int g = val_sign(v); int s = val_size(v); int t = val_type(v);
            if (t == VAL_TYPE_I) {
              if (s == VAL_SIZE_1) {
                printf(" %d", g == VAL_SIGN ? as_int8_t(v) : as_uint8_t(v));
              } else if (s == VAL_SIZE_2) {
                printf(" %d", g == VAL_SIGN ? as_int16_t(v) : as_uint16_t(v));
              } else if (s == VAL_SIZE_4) {
                printf(" %d", g == VAL_SIGN ? as_int32_t(v) : as_uint32_t(v));
              } else {
                printf(" %d", g == VAL_SIGN ? as_int64_t(v) : as_uint64_t(v));
              }
            } else if (t == VAL_TYPE_F) {
              printf(" %f", s == VAL_SIZE_4 ? as_float(v) : as_double(v));
            } else if (t == VAL_TYPE_S){
              char* p = NULL; int c = 0;
              as_str(&p, &c, v);
              if( p != NULL ){ 
                printf(" %.*s", c, p);
                free(p); 
              }
            } else {}
          }
          printf("\n");
        }
      }
      
      int main(int argc, char** argv) {
        if(!connect_to_server("192.168.5.10", 55555, "user", "user")){ return -1; }
        void* d = exec("create table tab1 (id u32(true), name string04());");
        if (d == NULL) { printf("execute sql failed\n"); return 0; }
        del_datas(d);
        d = exec("insert into tab1 (id,name) select seq(1000), x2str(seq(1000)+10);");
        if (d == NULL) { printf("execute sql failed\n"); return 0; }
        del_datas(d);
        d = exec("select id,name from tab1 where id < 10;");
        if( d == NULL ){ printf("execute sql failed\n"); return 0; }
        print(d);
        print_bymyself(d);
        del_datas(d);
        d = exec("drop table tab1;");
        exit_to_server();
        return 0;
      }

    Foire aux questions

    La connexion réseau a échoué
        1,Le côté local ne prend pas en charge les fonctions réseau, assurez-vous donc que le serveur est activé lors de l’utilisation du client pour se connecter afin de vous assurer que le port correspondant n’est pas occupé.
        2,Le shucan utilisestratégie d’authentification de connexion.S’assurer que le nombre d’opérations ne dépasse pas le seuil requis.

    La phrase where n’est pas prise en charge
    La phrase where n’est pas compatible avec le contenu SQL standard, et les instructions associées, telles que le filtrage conditionnel en ligne (id==name)、exist、group by ect doivent être converties enopérations de post-traitement des données

    Fonction reg_match ne fonctionne pas correctement
    La bibliothèque d’analyse d’expression régulière shucan est une implémentation d’ECMA-262 (version 2011), qui est compatible avec la syntaxe de la plupart des expressions régulières et ajoute \h correspondant chinois\H correspondant aux caractères limites non chinois. Afin d’éviter les interruptions de performances dans des cas particuliers, la bibliothèque d’expressions régulières utilise la correspondance sans retour en arrière par défaut, c’est-à-dire que .* correspondra à tous et que vous devez éviter d’utiliser .* lorsque vous l’utilisez.

    fuzzy_match est particulièrement lent
    La correspondance floue par défaut correspond à toutes les correspondances avec une différence inférieure à la moitié de la longueur, de sorte que l’algorithme de correspondance n’est pas efficace pour les chaînes plus longues.

    Retour d’erreur
    La base de données shucan a été soigneusement testée, mais certaines erreurs inconnues peuvent ne pas être évitées, veuillez envoyer une description du problème à la admin@shucantech.com erreurs associées. Merci pour vos commentaires!